关于点分治的理解

【引言】

由于树具有一般的图没有的特点，所以在竞赛中的应用更广。

在一些树上路径问题中，暴力求解时间复杂度过高，往往需要一些更为高效的算法，点分治就是其中之一。

【流程】

1、首先选取一个点，把无根树变成有根树。

　　那么如何选点呢？    ——树型动规

　　因为树是递归定义的，所以我们当然希望递归的层数最小。

　　每次选取的点，要保证与此点相连的结点数最多的连通块的结点数最小，我们把这个点叫做“重心”。

　　那么找到一颗树的重心有以下算法：

　　（1）dfs一次，算出以每个点为根的子树大小。

　　（2）记录以每个结点为根的最大子树的大小。

　　（3）判断：如果以当前结点为根的最大子树大小比当前根更优，更新当前根。

 1 void getroot(int x,int fa)//x表示当前结点，fa表示x的父结点
 2 {
 3     son[x]=1;F[x]=0;//F数组记录以x为根的最大子树的大小
 4     for(int i=Link[x];i;i=e[i].next)
 5         if(e[i].y!=fa&&!vis[e[i].y])//避免陷入死循环
 6         {
 7             getroot(e[i].y,x);//得到子结点信息
 8             son[x]+=son[e[i].y];//计算x结点大小
 9             F[x]=max(F[x],son[e[i].y]);//更新F数组
10         }
11     F[x]=max(F[x],sum-son[x]);//sum表示当前树的大小，因为以x为根的情况还要考虑以x的父亲为根的子树大小。
12     if(F[x]//更新当前根
13 }

2、处理联通块中通过根结点的路径。

3、标记根结点（相当于处理过后，将根结点从子树中删除）。

4、递归处理以当前点的儿子为根的每棵子树。

【算法框架】

 1 int solve(int x)
 2 { 
 3     vis[x]=1;//将当前点标记
 4     for(int i=Link[x];i;i=e[i].next)
 5         if(!vis[e[i].y])  
 6         {    
 7             root=0;//初始化根  
 8             sum=son[e[i].y];//初始化sum
 9             getroot(x,0);//找连通块的根
10             solve(root);//递归处理下一个连通块
11         }
12 }
13 int main()
14 {
15     build();//建树
16     sum=f[0]=n;//初始化sum和f[0]
17     root=0;//初始化root
18     getroot(1,0);//找根
19     solve(root);//点分治
20 }

【例题1】【poj1741】tree

给一颗n个节点的树，每条边上有一个距离v（v<=1000）。定义d(u,v)为u到v的最小距离。给定k值，求有多少点对（u，v）使u到v的距离小于等于k。数据范围：n<=10000,k<2^31

计算答案的方法：这个点延伸出的几棵子树各做一次dfs，记录子树中出现的距离值，对于一棵树的距离值数组，把它排序求一次ans1，再对每棵子树分别求一个自己对自己的ans2，ans1-Σans2即为最后的ans。

参考代码：

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #include
 7 #include
 8 using namespace std;
 9 #define INF 0x7fffffff
10 struct node{int y,v,next;}e[20010];
11 int n,len,k,root,sum,ans,Link[10010],f[10010],vis[10010],son[10010],d[10010],deep[10010];
12 inline int read()
13 {
14     int x=0,f=1;  char ch=getchar();
15     while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
16     while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
17     return x*f;
18 }
19 void insert(int x,int y,int v)
20 {
21     e[++len].next=Link[x];
22     Link[x]=len;
23     e[len].v=v;
24     e[len].y=y;
25 }
26 void getroot(int x,int fa)
27 {
28     son[x]=1;  f[x]=0;
29     for(int i=Link[x];i;i=e[i].next)
30     {
31         if(e[i].y==fa||vis[e[i].y])  continue;
32         getroot(e[i].y,x);
33         son[x]+=son[e[i].y];
34         f[x]=max(f[x],son[e[i].y]);
35     }
36     f[x]=max(f[x],sum-son[x]);
37     if(f[x]x;
38 }
39 void getdeep(int x,int fa)
40 {
41     deep[++deep[0]]=d[x];
42     for(int i=Link[x];i;i=e[i].next)
43     {
44         if(e[i].y==fa||vis[e[i].y])  continue;
45         d[e[i].y]=d[x]+e[i].v;
46         getdeep(e[i].y,x);
47     }
48 }
49 int cal(int x,int v)
50 {
51     d[x]=v;  deep[0]=0;
52     getdeep(x,0);
53     sort(deep+1,deep+deep[0]+1);
54     int l=1,r=deep[0],sum=0;
55     while(l<r)
56     {
57         if(deep[l]+deep[r]<=k)  {sum+=r-l;  l++;}
58         else r--;
59     }
60     return sum;
61 }
62 void solve(int x)
63 {
64     ans+=cal(x,0);//计算答案
65     vis[x]=1;
66     for(int i=Link[x];i;i=e[i].next)
67     {
68         if(vis[e[i].y])  continue;
69         ans-=cal(e[i].y,e[i].v);//计算不符合题意的答案
70         sum=son[e[i].y];
71         root=0;
72         getroot(e[i].y,0);
73         solve(root);
74     }
75 }
76 int main()
77 {
78     freopen("cin.in","r",stdin);
79     freopen("cout.out","w",stdout);
80     while(1)
81     {
82         ans=0,root=0,len=0;
83         memset(vis,0,sizeof(vis));
84         memset(Link,0,sizeof(Link));
85         n=read();  k=read();
86         if(n==0&&k==0)  break;
87         for(int i=1;i<=n-1;i++)
88         {
89             int x=read(),y=read(),v=read();
90             insert(x,y,v);   insert(y,x,v);
91         }
92         f[0]=INF;  sum=n;
93         getroot(1,0);
94         solve(root);
95         printf("%d\n",ans);
96     }
97     return 0;
98 }

【例题2】【bzoj2152】聪聪可可

聪聪和可可是兄弟俩，他们俩经常为了一些琐事打起来，例如家中只剩下最后一根冰棍而两人都想吃、两个人都想玩儿电脑（可是他们家只有一台电脑）……遇到这种问题，一般情况下石头剪刀布就好了，可是他们已经玩儿腻了这种低智商的游戏。他们的爸爸快被他们的争吵烦死了，所以他发明了一个新游戏：由爸爸在纸上画n个“点”，并用n-1条“边”把这n个“点”恰好连通（其实这就是一棵树）。并且每条“边”上都有一个数。接下来由聪聪和可可分别随即选一个点（当然他们选点时是看不到这棵树的），如果两个点之间所有边上数的和加起来恰好是3的倍数，则判聪聪赢，否则可可赢。聪聪非常爱思考问题，在每次游戏后都会仔细研究这棵树，希望知道对于这张图自己的获胜概率是多少。现请你帮忙求出这个值以验证聪聪的答案是否正确。

计算答案的方法：与上一题类似，在计算路径长度时对3取模，用t[0],t[1],t[2]分别记录模为0、1、2的情况，那么显然答案就是t[1]*t[2]*2+t[0]*t[0]

参考代码：

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #include
 7 #include
 8 using namespace std;
 9 #define MAXN 20010
10 struct node{int y,v,next;}e[MAXN*2];
11 int n,len,root,sum,ans,t[5],Link[MAXN],f[MAXN],vis[MAXN],son[MAXN],d[MAXN];
12 inline int read()
13 {
14     int x=0,f=1;  char ch=getchar();
15     while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
16     while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
17     return x*f;
18 }
19 int gcd(int a,int b)  {return b==0?a:gcd(b,a%b);}
20 void insert(int x,int y,int v)
21 {
22     e[++len].next=Link[x];
23     Link[x]=len;
24     e[len].y=y;
25     e[len].v=v;
26 }
27 void getroot(int x,int fa)
28 {
29     son[x]=1;  f[x]=0;
30     for(int i=Link[x];i;i=e[i].next)
31     {
32         if(e[i].y==fa||vis[e[i].y])  continue;
33         getroot(e[i].y,x);
34         son[x]+=son[e[i].y];
35         f[x]=max(f[x],son[e[i].y]);
36     }
37     f[x]=max(f[x],sum-son[x]);
38     if(f[x]x;
39 }
40 void getdeep(int x,int fa)
41 {
42     t[d[x]]++;
43     for(int i=Link[x];i;i=e[i].next)
44     {
45         if(e[i].y==fa||vis[e[i].y])  continue;
46         d[e[i].y]=(d[x]+e[i].v)%3;
47         getdeep(e[i].y,x);
48     }
49 }
50 int cal(int x,int v)
51 {
52     t[0]=t[1]=t[2]=0;  d[x]=v;
53     getdeep(x,0);
54     return t[1]*t[2]*2+t[0]*t[0];
55 }
56 void solve(int x)
57 {
58     ans+=cal(x,0);  vis[x]=1;
59     for(int i=Link[x];i;i=e[i].next)
60     {
61         if(vis[e[i].y])  continue;
62         ans-=cal(e[i].y,e[i].v);
63         root=0;  sum=son[e[i].y];
64         getroot(e[i].y,0);
65         solve(root);
66     }
67 }
68 int main()
69 {
70     //freopen("cin.in","r",stdin);
71     //freopen("cout.out","w",stdout);
72     n=read();
73     for(int i=1;i)
74     {
75         int x=read(),y=read(),v=read()%3;
76         insert(x,y,v);  insert(y,x,v);
77     }
78     sum=n;  f[0]=n;
79     getroot(1,0);
80     solve(root);
81     int t=gcd(ans,n*n);
82     printf("%d/%d\n",ans/t,n*n/t);
83     return 0;
84 }

【例题3】【bzoj2599】Race

给一棵树,每条边有权.求一条路径,权值和等于K,且边的数量最小.数据范围：N<=200000, K<=1000000

我的做法：开一个100W的数组t,t[i]表示权值为i的路径最少边数
　　　　　找到重心分成若干子树后， 得出一棵子树的所有点到根的权值和x，到根a条边，用t[k-x]+a更新答案，全部查询完后
　　　　  然后再用所有a更新t[x]
　　　　  这样可以保证不出现点分治中的不合法情况
　　　　  把一棵树的所有子树搞完后再遍历所有子树恢复T数组，如果用memset应该会比较慢

参考代码：

  1 #include
  2 #include
  3 #include
  4 #include
  5 #include
  6 #include
  7 #include
  8 using namespace std;
  9 #define MAXN 200100
 10 #define INF 1000000000
 11 struct node{int y,next,v;}e[MAXN*2];
 12 int n,m,len,root,sum,ans,Link[MAXN],son[MAXN],vis[MAXN],t[MAXN*5],dis[MAXN],d[MAXN],f[MAXN];
 13 char buf[1<<15],*fs,*ft;
 14 inline char getc()  {return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin)),fs==ft)?0:*fs++;}
 15 inline int read()
 16 {
 17     int x=0,f=1;  char ch=getc();
 18     while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getc();}
 19     while(isdigit(ch))  {x=x*10+ch-'0';  ch=getc();}
 20     return x*f;
 21 }
 22 void insert(int x,int y,int v){e[++len].next=Link[x];  Link[x]=len;  e[len].y=y;  e[len].v=v;}
 23 void getroot(int x,int fa)
 24 {
 25     int ff=1;   son[x]=1;
 26     for(int i=Link[x];i;i=e[i].next)
 27         if(e[i].y!=fa&&!vis[e[i].y])
 28         {
 29             getroot(e[i].y,x);
 30             son[x]+=son[e[i].y];
 31             if(son[e[i].y]>sum/2)  ff=0;
 32         }
 33     if(sum-son[x]>sum/2)  ff=0;
 34     if(ff)  root=x;
 35 }
 36 /*void getroot(int x,int fa)
 37 {
 38     son[x]=1;f[x]=0;
 39     for(int i=Link[x];i;i=e[i].next)
 40         if(e[i].y!=fa&&!vis[e[i].y])    
 41         {
 42             getroot(e[i].y,x);
 43             son[x]+=son[e[i].y];
 44             f[x]=max(f[x],son[e[i].y]);
 45         }
 46     f[x]=max(f[x],sum-son[x]);
 47     if(f[x] 48 }*/
 49 void cal(int x,int fa)
 50 {
 51     if(dis[x]<=m)  ans=min(ans,d[x]+t[m-dis[x]]);
 52     for(int i=Link[x];i;i=e[i].next)
 53         if(e[i].y!=fa&&!vis[e[i].y])
 54         {
 55             d[e[i].y]=d[x]+1;
 56             dis[e[i].y]=dis[x]+e[i].v;
 57             cal(e[i].y,x);
 58         }
 59 }
 60 void add(int x,int fa,int flag)
 61 {
 62     if(dis[x]<=m)  
 63     {
 64         if(flag)  t[dis[x]]=min(t[dis[x]],d[x]);
 65         else t[dis[x]]=INF;
 66     }
 67     for(int i=Link[x];i;i=e[i].next)
 68         if(e[i].y!=fa&&!vis[e[i].y])
 69             add(e[i].y,x,flag);
 70 }
 71 void work(int x)
 72 {
 73     vis[x]=1;  t[0]=0;
 74     for(int i=Link[x];i;i=e[i].next)
 75         if(!vis[e[i].y])
 76         {
 77             d[e[i].y]=1;  dis[e[i].y]=e[i].v;
 78             cal(e[i].y,0);
 79             add(e[i].y,0,1);
 80         }
 81     for(int i=Link[x];i;i=e[i].next)
 82         if(!vis[e[i].y])  add(e[i].y,0,0);    
 83     for(int i=Link[x];i;i=e[i].next)
 84         if(!vis[e[i].y])
 85         {
 86             sum=son[e[i].y];  root=0;
 87             getroot(e[i].y,0);
 88             work(e[i].y);
 89         }
 90 }
 91 int main()
 92 {
 93     //freopen("cin.in","r",stdin);
 94     //freopen("cout.out","w",stdout);
 95     n=read();  m=read();
 96     for(int i=1;i<=m;i++)t[i]=n;
 97     for(int i=1;i)
 98     {
 99         int x=read(),y=read(),v=read();
100         x++;  y++;
101         insert(x,y,v);  insert(y,x,v);
102     }
103     sum=ans=f[0]=n;
104     getroot(1,0);
105     work(root);
106     if(ans==n)  printf("-1\n");
107     else printf("%d\n",ans);
108     return 0;
109 }

【例题4】【bzoj3697】采药人的路径

采药人的药田是一个树状结构，每条路径上都种植着同种药材。
采药人以自己对药材独到的见解，对每种药材进行了分类。大致分为两类，一种是阴性的，一种是阳性的。
采药人每天都要进行采药活动。他选择的路径是很有讲究的，他认为阴阳平衡是很重要的，所以他走的一定是两种药材数目相等的路径。采药工作是很辛苦的，所以他希望他选出的路径中有一个可以作为休息站的节点（不包括起点和终点），满足起点到休息站和休息站到终点的路径也是阴阳平衡的。他想知道他一共可以选择多少种不同的路径。

来自出题人hta的题解：
本题可以考虑树的点分治。问题就变成求过根满足条件的路径数。
路径上的休息站一定是在起点到根的路径上，或者根到终点的路径上。
如何判断一条从根出发的路径是否包含休息站？只要在dfs中记录下这条路径的和x，同时用个标志数组判断这条路径是否存在前缀和为x的节点。
这样我们枚举根节点的每个子树。用f[i][0…1]，g[i][0…1]分别表示前面几个子树以及当前子树和为i的路径数目，0和1用于区分路径上是否存在前缀和为i的节点。那么当前子树的贡献就是f[0][0] * g[0][0] + Σf [i][0] * g [-i][1] + f[i][1] * g[-i][0] + f[i][1] * g[-i][1]，其中i的范围[-d,d]，d为当前子树的深度。

 参考代码：

 1 #include
 2 #include
 3 #include
 4 #include
 5 #include
 6 #include
 7 #include
 8 using namespace std;
 9 #define MAXN 200100
10 struct node{int y,next,v;}e[MAXN];
11 int n,len,sum,root,mxdeep,Link[MAXN],son[MAXN],deep[MAXN],vis[MAXN],dis[MAXN],t[MAXN],F[MAXN];
12 long long ans,f[MAXN][2],g[MAXN][2];
13 inline int read()
14 {
15     int x=0,f=1;  char ch=getchar();
16     while(!isdigit(ch))  {if(ch=='-')  f=-1;  ch=getchar();}
17     while(isdigit(ch))  {x=x*10+ch-'0';  ch=getchar();}
18     return x*f;
19 }
20 void insert(int x,int y,int v) {e[++len].next=Link[x]; Link[x]=len; e[len].y=y; e[len].v=v;}
21 void getroot(int x,int fa)
22 {
23     son[x]=1;F[x]=0;
24     for(int i=Link[x];i;i=e[i].next)
25         if(e[i].y!=fa&&!vis[e[i].y])
26         {
27             getroot(e[i].y,x);
28             son[x]+=son[e[i].y];
29             F[x]=max(F[x],son[e[i].y]);
30         }
31     F[x]=max(F[x],sum-son[x]);
32     if(F[x]x;
33 }
34 void dfs(int x,int fa)
35 {
36     mxdeep=max(mxdeep,deep[x]);
37     if(t[dis[x]])  f[dis[x]][1]++;
38     else f[dis[x]][0]++;
39     t[dis[x]]++;
40     for(int i=Link[x];i;i=e[i].next)
41         if(!vis[e[i].y]&&e[i].y!=fa)
42         {
43             dis[e[i].y]=dis[x]+e[i].v;
44             deep[e[i].y]=deep[x]+1;
45             dfs(e[i].y,x);
46         }
47     t[dis[x]]--;
48 }
49 void work(int x)
50 {
51     g[n][0]=1;  vis[x]=1;  int mx=0;
52     for(int i=Link[x];i;i=e[i].next)
53         if(!vis[e[i].y])
54         {
55             dis[e[i].y]=n+e[i].v;  deep[e[i].y]=1;
56             mxdeep=1;  dfs(e[i].y,0);  mx=max(mx,mxdeep);
57             ans+=(g[n][0]-1)*f[n][0];
58             for(int j=-mxdeep;j<=mxdeep;j++)
59                 ans+=g[n-j][1]*f[n+j][1]+g[n-j][0]*f[n+j][1]+g[n-j][1]*f[n+j][0];
60             for(int j=n-mxdeep;j<=n+mxdeep;j++)
61             {
62                 g[j][0]+=f[j][0];
63                 g[j][1]+=f[j][1];
64                 f[j][0]=f[j][1]=0;
65             }
66         }
67     for(int i=n-mx;i<=n+mx;i++)
68         g[i][0]=g[i][1]=0;
69     for(int i=Link[x];i;i=e[i].next)
70         if(!vis[e[i].y])
71         {
72             root=0;
73             sum=son[e[i].y];
74             getroot(e[i].y,0);
75             work(root);
76         }
77 }
78 int main()
79 {
80     //freopen("cin.in","r",stdin);
81     //freopen("cout.out","w",stdout);
82     n=read();
83     for(int i=1;i)
84     {
85         int x=read(),y=read(),v=read();
86         if(!v)  v=-1;
87         insert(x,y,v);  insert(y,x,v);
88     }
89     sum=F[0]=n;
90     getroot(1,0);
91     work(root);
92     printf("%lld\n",ans);
93     return 0;
94 }

 

转载于:https://www.cnblogs.com/chty/p/5912360.html