2. 程式人生 > >樹上統計treecnt(dsu on tree 並查集 正難則反)

樹上統計treecnt(dsu on tree 並查集 正難則反)

阿新 • • 發佈：2018-09-21
problem freopen space script type 題目 每次 分割 pos

題目鏈接

\(Description\)

給定一棵\(n(n\leq 10^5)\)個點的樹。
定義\(Tree[L,R]\)表示為了使得\(L\sim R\)號點兩兩連通，最少需要選擇的邊的數量。
求\[\sum_{l=1}^n\sum_{r=l}^nTree[l,r]\]

\(Solution\)

枚舉每條邊，計算它的貢獻。
那麽我們要判斷有多少連續區間的點跨過這條邊，並不好算，反過來去求在這條邊的兩側分別有多少個連續區間。
那麽顯然有\(O(n^2)\)的做法，即對每條邊DFS它的兩側，枚舉一下每一側的連續區間。
我們還可以DFS這棵樹，對於每個點我們需要計算它子樹內和子樹外的連續區間數。

對於子樹內的點，並查集顯然是可以維護的（每次合並相鄰點成為一個連續區間時新產生的連續區間數可算，就是兩個集合\(size\)的乘積）。
對於子樹外的點怎麽算呢。我們可以先假設子樹外為\(1,2,...,n\)，且有這些區間。我們每次在子樹中加入點時，就把它從子樹外的集合的點中刪掉，並計算子樹外少的區間數。
我們發現不需要\(n\)個元素的集合，也不需要這樣刪。在一個初始只有\(0\)和\(n+1\)的空集合裏，每次加入子樹內的點，然後計算，也是等價的。
於是我們需要對每個子樹合並並查集及處理set。
可以用dsu on tree，每次先處理完輕兒子的子樹，每次處理完都清空那棵子樹的貢獻/狀態（並查集、set）。最後處理重兒子所在子樹，並保留其狀態。
處理完這整棵子樹後（也就是算完該邊答案後），再把子樹內其它未加入的輕子樹給加入並查集、set。
dsu的復雜度是\(O(n\log n)\)的，再套上別的，復雜度為\(O(n\log^2n)\)。

#include <set>
#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 150000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
#define Calc(x) (1ll*(x)*(x-1)>>1ll)//區間個數 
typedef long long LL;
const int N=1e5+5;

int n,Enum,H[N],nxt[N<<1],to[N<<1],fa[N],sz[N],son[N],Fa[N],size[N];
bool vis[N];//計算子樹內的連續區間（是否子樹內已存在相鄰的）
LL Ans,sum1,sum2;
std::set<int> st;
char IN[MAXIN],*SS=IN,*TT=IN;

inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}
inline void AE(int u,int v)
{
    to[++Enum]=v, nxt[Enum]=H[u], H[u]=Enum;
    to[++Enum]=u, nxt[Enum]=H[v], H[v]=Enum;
}
void DFS1(int x)
{
    int mx=0; sz[x]=1;
    for(int i=H[x],v; i; i=nxt[i])
        if((v=to[i])!=fa[x])
        {
            fa[v]=x, DFS1(v), sz[x]+=sz[v];
            if(sz[v]>mx) mx=sz[v], son[x]=v;
        }
}
int Find(int x)
{
    return x==Fa[x]?x:Fa[x]=Find(Fa[x]);
}
void Upd(int x)
{
    st.insert(x);//我怎麽記得有返回值(iterator)來...
    std::set<int>::iterator it=st.find(x),pre=it,nxt=++it;
    --pre;
    sum2-=Calc(*nxt-*pre-1);//子樹外以前的連續區間被分割 
    sum2+=Calc(x-*pre-1)+Calc(*nxt-x-1);

    vis[x]=1;
    if(vis[x-1])
    {
        int r1=Find(x-1),r2=Find(x);//它們之前顯然不會在一個集合啊（它們之間只會算一次，要麽是加x-1，以前有x；要麽是加x，以前有x-1）。
        sum1+=1ll*size[r1]*size[r2];
        Fa[r1]=r2, size[r2]+=size[r1];
    }
    if(vis[x+1])
    {
        int r1=Find(x+1),r2=Find(x);
        sum1+=1ll*size[r1]*size[r2];
        Fa[r1]=r2, size[r2]+=size[r1];
    }
}
void Clear(int x)
{
    Fa[x]=x, size[x]=1, vis[x]=0;
    for(int i=H[x]; i; i=nxt[i])
        if(to[i]!=fa[x]) Clear(to[i]);
}
void Update(int x)
{
    Upd(x);
    for(int i=H[x]; i; i=nxt[i])
        if(to[i]!=fa[x]) Update(to[i]);
}
void DFS2(int x)
{
    for(int i=H[x],v; i; i=nxt[i])
        if((v=to[i])!=fa[x]&&v!=son[x])
        {
            DFS2(v), Clear(v);
            st.clear(), st.insert(0), st.insert(n+1);
            sum1=0, sum2=Calc(n);//還是在DFS完子樹後就初始化吧 
        }
    if(son[x]) DFS2(son[x]);

    for(int i=H[x],v; i; i=nxt[i])
        if((v=to[i])!=fa[x]&&v!=son[x]) Update(v);

    Upd(x);
    Ans+=Calc(n)-sum1-sum2;
}

int main()
{
    freopen("treecnt.in","r",stdin);
    freopen("treecnt.out","w",stdout);

    n=read();
    for(int i=1; i<n; ++i) AE(read(),read());
    for(int i=1; i<=n; ++i) Fa[i]=i,size[i]=1;//!
    st.insert(0), st.insert(n+1);//邊界.
    sum1=0, sum2=Calc(n), DFS1(1), DFS2(1), printf("%lld\n",Ans);

    return 0;
}

另一種\(O(n^2)\)做法：

#include <set>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 300000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=1e5+5,INF=0x3f3f3f3f;

int dgr[N],Enum,H[N],nxt[N<<1],to[N<<1],fa[N],dep[N],sz[N],son[N],top[N],dfn[N],ref[N];
char IN[MAXIN],*SS=IN,*TT=IN;

inline int read()
{
    int now=0;register char c=gc();
    for(;!isdigit(c);c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now;
}
inline void AE(int u,int v)
{
//  ++dgr[u], ++dgr[v];
    to[++Enum]=v, nxt[Enum]=H[u], H[u]=Enum;
    to[++Enum]=u, nxt[Enum]=H[v], H[v]=Enum;
}
inline int LCA(int u,int v)
{
//  printf("LCA(%d,%d)\n",u,v);
    while(top[u]!=top[v]) dep[top[u]]>dep[top[v]]?u=fa[top[u]]:v=fa[top[v]];
    return dep[u]>dep[v]?v:u;
}
inline int Dis(int u,int v)
{
//  printf("(%d,%d) Subd:dep[%d]=%d!\n",u,v,LCA(u,v),dep[LCA(u,v)]);
    return dep[u]+dep[v]-(dep[LCA(u,v)]<<1);
}
void DFS1(int x)
{
    int mx=0; sz[x]=1;
    for(int i=H[x],v; i; i=nxt[i])
        if((v=to[i])!=fa[x])
        {
            fa[v]=x, dep[v]=dep[x]+1, DFS1(v), sz[x]+=sz[v];
            if(sz[v]>mx) mx=sz[v], son[x]=v;
        }
}
void DFS2(int x,int tp)
{
    static int Index=0;

    top[x]=tp, dfn[x]=++Index;
    if(son[x])
    {
        DFS2(son[x],tp);
        for(int i=H[x]; i; i=nxt[i])
            if(to[i]!=fa[x]&&to[i]!=son[x]) DFS2(to[i],to[i]);
    }
}
inline bool cmp_dfn(int i,int j)
{
    return dfn[i]<dfn[j];
}
void Output(int *l,int *r,int n)
{
    printf("\nOutput the list:\n%d",0);
    for(int p=r[0]; p!=n+1; p=r[p]) printf("->%d(%d)",p,l[p]); puts("\n");
}
void Subtask0(int n)
{
    const int N=305;
    static int A[N];

    LL ans=0;
    for(int i=1; i<=n; ++i)
    {
        int t=1; A[1]=i;
        for(int j=i+1; j<=n; ++j)
        {
            A[++t]=j, std::sort(A+1,A+1+t,cmp_dfn);
            for(int k=1; k<t; ++k) ans+=Dis(A[k],A[k+1]);
            ans+=Dis(A[t],A[1]);
        }
    }
    printf("%I64d\n",ans>>1ll);
}
void Subtask1(int n)
{
    const int N=3005;
    static int A[N],SL[N],SR[N],L[N],R[N],id[N],tl[N],tr[N];

    LL ans=0;
    for(int i=1; i<=n; ++i) ans+=1ll*(1ll*(i-1)*(n-i+1)+n-i)*dep[i],id[i]=i;
//  printf("pre_ans=%I64d\n\n",ans);

    std::sort(id+1,id+1+n,cmp_dfn);
    SR[0]=id[1], SL[n+1]=id[n], id[n+1]=n+1;
    for(int i=1; i<=n; ++i) SL[id[i]]=id[i-1], SR[id[i]]=id[i+1];

//  for(int i=1; i<=n; ++i) printf("dfn[%d]=%d\n",i,dfn[i]); puts("");
//  Output(SL,SR,n);

    for(int i=1; i<n; ++i)
    {
        memset(tl,0,sizeof tl), memset(tr,0,sizeof tr);
        memcpy(L,SL,sizeof SL), memcpy(R,SR,sizeof SR);
//      Output(L,R,n);

        for(int j=n,T=1,l,r; j>i; --j,++T)
        {
            int a,b;
            if((l=L[j])==0) a=j, b=L[n+1];
            else a=j, b=l;
            int tmp=std::min(T-tr[b],T-tl[a]);
            ans-=1ll*tmp*dep[LCA(a,b)], tr[b]=T;

            if((r=R[j])==n+1) b=j, a=R[0];
            else b=j, a=r;
            tmp=std::min(T-tr[b],T-tl[a]);
            ans-=1ll*tmp*dep[LCA(a,b)], tl[a]=T;

            R[l]=r, L[r]=l;

//          if((l=L[j])==0) ans-=dep[LCA(j,L[n+1])], printf("Subd:dep[%d]=%d!\n",LCA(j,L[n+1]),dep[LCA(j,L[n+1])]);
//          else ans-=dep[LCA(j,l)], printf("Subd:dep[%d]=%d!\n",LCA(j,l),dep[LCA(j,l)]);
//          if((r=R[j])==n+1) ans-=dep[LCA(j,R[0])], printf("Subd:dep[%d]=%d!\n",LCA(j,R[0]),dep[LCA(j,R[0])]);
//          else ans-=dep[LCA(j,r)], printf("Subd:dep[%d]=%d!\n",LCA(j,r),dep[LCA(j,r)]);
//          R[l]=r, L[r]=l;
        }
        SR[SL[i]]=SR[i], SL[SR[i]]=SL[i];
    }
    printf("%I64d\n",ans);
}
namespace Subtask2
{
//  struct BIT
//  {
//      #define lb(x) (x&-x)
//      int n,mn[N],mx[N];
//  
//      void Init(int nn) {n=nn; memset(mn,0x3f,sizeof mn), memset(mx,0,sizeof mx);}
//      void Modify_Max(int p,int v)
//      {
//          for(; p<=n; p+=lb(p)) mx[p]=std::max(mx[p],v);
//      }
//      void Modify_Min(int p,int v)
//      {
//          for(; p<=n; p+=lb(p)) mn[p]=std::min(mn[p],v);
//      }
//      int Query_Max(int p)
//      {
//          int res=0;
//          for(; p; p^=lb(p)) res=std::max(res,mx[p]);
//          return res;
//      }
//      int Query_Min(int p)
//      {
//          int res=INF;
//          for(; p; p^=lb(p)) res=std::min(res,mn[p]);
//          return res;
//      }
//  }Tp,Ts;
//  int pos[N],ref[N];
//
//  void DFS3(int x,int f,int t)
//  {
////        pos[x]=t, ref[t]=x;
//      pos[t]=x;
//      for(int i=H[x]; i; i=nxt[i])
//          if(to[i]!=f) DFS3(to[i],x,t+1);
//  }
//  bool Main(int n)
//  {
//      for(int i=1; i<=n; ++i) if(dgr[i]>2) return 0;
//      for(int i=1; i<=n; ++i) if(dgr[i]==1) {DFS3(i,i,1); break;}
//
//      LL ans=0;
//      Tp.Init(n), Ts.Init(n);
//      for(int i=n; i; --i)
//      {
//          int p=pos[i],l=Tp.Query_Max(p)+1,r=Ts.Query_Min(n-p+1)-1;
////            if(l==0+1) l=1;
//          if(r==INF-1) r=n;
//          ans+=1ll*i*(p-l+1)*(r-p+1);
//          Tp.Modify_Max(p,p), Ts.Modify_Min(n-p+1,p);
//      }
//  
//      Tp.Init(n), Ts.Init(n);
//      for(int i=1; i<=n; ++i)
//      {
//          int p=pos[i],l=Tp.Query_Max(p)+1,r=Ts.Query_Min(n-p+1)-1;
////            if(l==0+1) l=1;
//          if(r==INF-1) r=n;
//          ans-=1ll*i*(p-l+1)*(r-p+1);
//          Tp.Modify_Max(p,p), Ts.Modify_Min(n-p+1,p);
//      }
//      printf("%I64d\n",ans);
//      return 1;
//  }
}

int main()
{
    freopen("treecnt.in","r",stdin);
    freopen("treecnt.out","w",stdout);

    int n=read();
    for(int i=1; i<n; ++i) AE(read(),read());

//  if(n>3000 && Subtask2::Main(n)) return 0;

    DFS1(1), DFS2(1,1);
//  Subtask0(n); puts("");
    if(n<=300) Subtask0(n);
    else if(n<=3000||1) Subtask1(n);

    return 0;
}

樹上統計treecnt(dsu on tree 並查集 正難則反)

相關推薦

樹上統計treecnt(dsu on tree 並查集 正難則反)

problem freopen space script type 題目 每次 分割 pos 題目鏈接 \(Description\) 給定一棵\(n(n\leq 10^5)\)個點的樹。 定義\(Tree[L,R]\)表示為了使得\(L\sim R\)號點兩兩連通，最少需

【CF 600 E】Lomsat gelral——樹上啟發式合併dsu on tree入門

一.前言： 這次講解的dsu on tree，其實是一種優美的暴力，它的時間複雜度分析與樹鏈剖分類似，也需要用到重兒子這一概念（不會樹剖的點這裡）. 這種演算法適用於一類樹上查詢子樹的問題，不過它只能處理有子樹查詢的問題，不支援修改，也不支援鏈查詢. 二.例題：

[BZOJ2599][IOI2011]Race-樹上啟發式合併(dsu on tree)

Race Description 給一棵樹,每條邊有權.求一條簡單路徑,權值和等於K,且邊的數量最小.N <= 200000, K <= 1000000 Input 第一行 兩個整數 n, k 第二..n行 每行三個整數 表示一條無

樹上啟發式合併 DSU On Tree

前言 這個演算法是退役之後才知道的…… 大概作用是支援靜態的樹上的一些對子樹資訊的離線詢問。 和樹上莫隊很像，也是按照一個順序來處理詢問，要求在外部能較快速地維護當前選入點的資訊。 和樹鏈剖分很像，也是先找出重兒子和輕兒子，兩種按一定次序處理，也因此保證

bzoj2870 最長道路tree 並查集+樹的直徑

Description H城很大，有N個路口（從1到N編號），路口之間有N-1邊，使得任意兩個路口都能互相到達，這些道路的長度我們視作一樣。每個路口都有很多車輛來往，所以每個路口i都有一個擁擠程度v[i]，我們認為從路口s走到路口t的痛苦程度為s到t的路徑上擁擠程度的最小值，乘

hdu 1325Is It A Tree?(並查集判斷有向樹）

Problem Description A tree is a well-known data structure that is either empty (null, void, nothing) or is a set of one or more nodes connected by d

hdu 1325/poj 1308 Is It A Tree? 並查集

A tree is a well-known data structure that is either empty (null, void, nothing) or is a set of one or more nodes connected by directed edges between

HDU-1116-Play on Words (並查集 +歐拉回路）

原題連結： http://acm.hdu.edu.cn/showproblem.php?pid=1116 Some of the secret doors contain a very interesting word puzzle. The team of archaeologists

小希的迷宮 && Is It A Tree?——並查集 / 圖轉化成樹

一、無向圖轉化成樹 （也可用並查集） Description 上次Gardon的迷宮城堡小希玩了很久（見Problem B），現在她也想設計一個迷宮讓Gardon來走。但是她設計迷宮的思路不一樣，首先她認為所有的通道都應該是雙向連通的，就是說如果有一個通道連通了房間A和B

Poj1308 Is It A Tree? 並查集

Description A tree is a well-known data structure that is either empty (null, void, nothing) or is a set of one or more nodes connected

10129 Play on Words-----並查集+尤拉路！！！

題意：判斷所有字串是不是可以連在一起，實際上就是判斷所構造的有向圖是否存在歐拉回路或者尤拉圖； #include<iostream> #include<cstdio> #include<cmath> #include<cstri

hdu 5606 tree 並查集

1 in the sample. $ans_1=2$ $ans_2=2$ $ans_3=1$ $2~xor~2~xor~1=1$,so you need to output 1.題意：給出幾組資料，每組資料有m（1-m）個點，然後給出m-1組兩點之間的距離，距離只可能為1或者為0，求出距離每個點最

hdu1325 Is It A Tree?並查集

題目地址 單看題目的話和hdu1272是一樣的。但是hdu1272的博文中我也說了，資料比較水，所以我用非並查集的方法就AC了。但是這題的資料沒那麼水，要用到並查集來解。這題的盲點和重點有這麼幾個： 輸入不是以-1 -1結束，而是以兩個負數結束需要用並查集來判斷是不是隻有

hdu 1325/poj 1308 Is It A Tree? 並查集

題目連結 題意：給出n條有向邊，判斷是不是一棵樹。 這題和hdu1272題目類似，只是把無向邊改成了有向邊。多加一個判斷條件，保證子節點是根節點。 #include <iostream>

HDU 3047 Zjnu Stadium（帶權並查集，難想到）

union blank then submit urn lin lock sts count M - Zjnu Stadium Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d

圖論-樹上啟發式合並(DSU On Tree)

pac code include clu 修改 += disjoint namespace std Disjoint Set Union On Tree ，似乎是來自 Codeforces 的一種新操作，似乎被叫做“樹上啟發式合並”。 在不帶修改的有根樹子樹信息統計問題中，

dsu on tree 樹上啟發式合並 學習筆記

for 時間 奇數 優化 遞歸 復雜度 數組 當前 編號 近幾天跟著dreagonm大佬學習了\(dsu\ on\ tree\)，來總結一下： \(dsu\ on\ tree\)，也就是樹上啟發式合並，是用來處理一類離線的樹上詢問問題（比如子樹內的顏色種數）的不二法寶。它不

dsu on tree 樹上啟發式合併 學習筆記

近幾天跟著dreagonm大佬學習了\(dsu\ on\ tree\)，來總結一下： \(dsu\ on\ tree\)，也就是樹上啟發式合併，是用來處理一類離線的樹上詢問問題（比如子樹內的顏色種數）的不二法寶。它不僅好想好寫，還有著\(O(nlogn)\)的優秀時間複雜度（劃重點）。 結合一道例題來講吧：

[CF600E]Lomsat gelral[dsu on tree/樹上啟發式合併]

題意：求每個節點子樹眾數和（比如3和5都是眾數 答案是8） 樹上啟發式合併可以解決一些無修改的子樹詢問 先solve輕兒子，後solve重兒子，如果該節點是輕兒子，然後重新統計輕兒子的貢獻，更新該節點的答案，如果該節點是輕兒子，那麼將該節點的貢獻刪除，回溯（其實就是保留了重兒子的答案） 由於輕重鏈剖分一

學習總結：Dsu on tree 樹上啟發式合併

（RT，這只是一篇小小的總結，以便將來的回顧，並不詳細講） 以前也學習過啟發式合併，大概就是像樹形dp一樣在dfs上，將兒子的資訊向父親轉移，容器是map，將兒子的資訊邊轉移邊更新答案，轉移之後便將兒子的容器清空，防止空間超限。不過對於本人而言，雖然思路較為簡