树分治（点分治模板）poj-1741 Tree

转载：http://blog.csdn.net/ezereal/article/details/52833620

对于一棵有根树， 树中满足要求的一个数对所对应的一条路径，必然是以下两种情况之一：

1、经过根节点
2、不经过根节点，也就是说在根节点的一棵子树中
对于情况2，可以递归求解，下面主要来考虑情况1。

设点i的深度为Depth[i]，父亲为Parent[i]。
若i为根，则Belong[i]=-1，若Parent[i]为根，则Belong[i]=i，否则Belong[i]=Belong[Parent[i]]。
这三个量都可以通过一次BFS求得。
我们的目标是要统计：有多少对(i,j)满足i<j，Depth[i]+Depth[j]<=K且Belong[i]<>Belong[j]

如果这样考虑问题会变得比较麻烦，我们可以考虑换一种角度：
设X为满足i<j且Depth[i]+Depth[j]<=K的数对(i,j)的个数
设Y为满足i<j，Depth[i]+Depth[j]<=K且Belong[i]=Belong[j]数对(i,j)的个数
那么我们要统计的量便等于X-Y

求X、Y的过程均可以转化为以下问题：
已知A[1],A[2],...A[m]，求满足i<j且A[i]+A[j]<=K的数对(i,j)的个数

对于这个问题，我们先将A从小到大排序。
设B[i]表示满足A[i]+A[p]<=K的最大的p(若不存在则为0)。我们的任务便转化为求出A所对应的B数组。那么，若B[i]>i，那么i对答案的贡献为B[i]-i。
显然，随着i的增大，B[i]的值是不会增大的。利用这个性质，我们可以在线性的时间内求出B数组，从而得到答案。

综上，设递归最大层数为L，因为每一层的时间复杂度均为“瓶颈”——排序的时间复杂度O(NlogN)，所以总的时间复杂度为O(L*NlogN)

然而，如果遇到极端情况——这棵树是一根链，那么随意分割势必会导致层数达到O(N)级别，对于N=10000的数据是无法承受的。因此，我们在每一棵子树中选择“最优”的点分割。所谓“最优”，是指删除这个点后最大的子树尽量小。这个点可以通过树形DP在O(N)时间内求出，不会增加时间复杂度。这样一来，即使是遇到一根链的情况时，L的值也仅仅是O(logN)的。

简单来说：点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。边分治就是每次找到一条边，使得删掉这条边后分成的两棵子树大小尽可能平均，然后以删掉的边的两端点为根，分别统计根到两棵树中的每个结点的路径信息，最后合并算路径，即可得到包含这条边的所有路径的信息，剩下的路径在两棵树中递归处理。

题意：找出树中有多少点对，满足dis（u，v）<K

思路：点分治模板题

[cpp]  view plain  copy

 

1. #include<iostream>  
2. #include<cstdio>  
3. #include<string>  
4. #include<cstring>  
5. #include<vector>  
6. #include<cmath>  
7. #include<queue>  
8. #include<stack>  
9. #include<map>  
10. #include<set>  
11. #include<algorithm>  
12. using namespace std;  
13. const int maxn=10010;  
14. int N,K;  
15. int ans,root,Max;  
16. struct node  
17. {  
18.     int v,next,w;  
19. }edge[maxn*2];  
20. int head[maxn],tot;  
21. int size[maxn];//树的大小  
22. int maxv[maxn];//最大孩子节点的size  
23. int vis[maxn];  
24. int dis[maxn];  
25. int num;  
26. void init()  
27. {  
28.     tot=0;  
29.     ans=0;  
30.     memset(head,-1,sizeof(head));  
31.     memset(vis,0,sizeof(vis));  
32. }  
33. void add_edge(int u,int v,int w)  
34. {  
35.     edge[tot].v=v;  
36.     edge[tot].w=w;  
37.     edge[tot].next=head[u];  
38.     head[u]=tot++;  
39. }  
40. //处理子树的大小  
41. void dfssize(int u,int f)  
42. {  
43.     size[u]=1;  
44.     maxv[u]=0;  
45.     for(int i=head[u];i!=-1;i=edge[i].next)  
46.     {  
47.         int v=edge[i].v;  
48.         if(v==f||vis[v])continue;  
49.         dfssize(v,u);  
50.         size[u]+=size[v];  
51.         if(size[v]>maxv[u])maxv[u]=size[v];  
52.     }  
53. }  
54. //找重心  
55. void dfsroot(int r,int u,int f)  
56. {  
57.     if(size[r]-size[u]>maxv[u])//size[r]-size[u]是u上面部分的树的尺寸，跟u的最大孩子比，找到最大孩子的最小差值节点  
58.         maxv[u]=size[r]-size[u];  
59.     if(maxv[u]<Max)Max=maxv[u],root=u;  
60.     for(int i=head[u];i!=-1;i=edge[i].next)  
61.     {  
62.         int v=edge[i].v;  
63.         if(v==f||vis[v])continue;  
64.         dfsroot(r,v,u);  
65.     }  
66. }  
67. //求每个点离重心的距离  
68. void dfsdis(int u,int d,int f)  
69. {  
70.     dis[num++]=d;  
71.     for(int i=head[u];i!=-1;i=edge[i].next)  
72.     {  
73.         int v=edge[i].v;  
74.         if(v!=f&&!vis[v])  
75.             dfsdis(v,d+edge[i].w,u);  
76.     }  
77. }  
78. //计算以u为根的子树中有多少点对的距离小于等于K  
79. int calc(int u,int d)  
80. {  
81.     int ret=0;  
82.     num=0;  
83.     dfsdis(u,d,0);  
84.     sort(dis,dis+num);  
85.     int i=0,j=num-1;  
86.     while(i<j)  
87.     {  
88.         while(dis[i]+dis[j]>K&&i<j)j--;  
89.         ret+=j-i;  
90.         i++;  
91.     }  
92.     return ret;  
93. }  
94. void dfs(int u)  
95. {  
96.     Max=N;  
97.     dfssize(u,0);  
98.     dfsroot(u,u,0);  
99.     ans+=calc(root,0);  
100.     vis[root]=1;  
101.     for(int i=head[root];i!=-1;i=edge[i].next)  
102.     {  
103.         int v=edge[i].v;  
104.         if(!vis[v])  
105.         {  
106.             ans-=calc(v,edge[i].w);  
107.             dfs(v);  
108.         }  
109.     }  
110. }  
111. int main()  
112. {  
113.     while(scanf("%d%d",&N,&K)!=EOF)  
114.     {  
115.         if(!N&&!K)break;  
116.         int u,v,w;  
117.         init();  
118.         for(int i=1;i<N;i++)  
119.         {  
120.             scanf("%d%d%d",&u,&v,&w);  
121.             add_edge(u,v,w);  
122.             add_edge(v,u,w);  
123.         }  
124.   
125.         dfs(1);  
126.         printf("%d\n",ans);  
127.     }  
128.     return 0;  
129. }