淀粉质点分治可真是个好东西
Part A.点分治
众所周知,树上分治算法有$3$种:点分治、边分治、链分治(最后一个似乎就是树链剖分),它们名字的不同是由于分治方式的不同的。点分治,顾名思义,每一次选择一个点进行分治,对于树上路径统计类型的问题有奇效,思路很好理解,只是码量有些烦人
先来看一道模板题:CF161D
至于为什么我没有放Luogu模板题是因为那道题只会写$O(n^2logn)$的算法(然而跑得过是因为跑不满)
这道题要求在$N$个点的树上找距离为$K$的点对的数量。
因为我们是来学点分治的,所以我们考虑点分治。我们每一次选择一个分治中心,那么以这一个分治中心为根,这棵树就会有若干子树。这棵树上的路径被分为了两种:
①经过分治中心
②没有经过分治中心,也就是说这条路径在以当前分治中心为根的一棵子树内
我们可以递归解决②对应的问题,也就是说我们只要解决当前树的①问题。
考虑每一次选择一棵子树对其进行深度优先搜索,开一个桶记录之前经过的子树中每一种路径长度对应的路径数量(一个小注明:路径指的是当前分治中心到达子树中某一个点的路径,下同)。每一次找到一条长度为$L$的路径之后,它对答案的贡献就是之前搜索过的子树中长度为$K-L$的路径的数量,因为这一条路径可以与这一些路径中的每一条拼接形成长度为$K$且经过当前分治中心的路径。在一棵子树遍历完了之后,再将这一棵子树的路径放入桶内。注意:不能找到一条路径就放进桶里面,因为这样可能会导致同一棵子树的两条路径被拼接并计入答案,但实际上它们之间的树上路径属于②,不应该在当前分治中心被统计到。当前分治中心解决之后,清空桶中元素,分治解决以当前分治中心为根的子树上的路径。
当然,你会发现一个问题:如果给出了一条链,结果你每一次选择的分治中心都是链两端的点,那复杂度不轻松卡成$O(n^2)$???
然而智慧的你不会让出题人这么轻松地卡掉你,我们考虑每一次选择一个点,以它为根时,子树大小尽量平均,也就是说最大的子树要尽量的小
那么我们当然会选择——树的重心!
因为树的重心的优雅性质(以它为根的子树的大小不超过当前树大小的$\frac{1}{2}$),我们每一次分治下去的子树的大小都至少会减半,也就保证了$O(nlogn)$的复杂度。
代码在下面(虽然我写的是双指针统计路径条数,这一种方法会在下面的那道题目里提到)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h> 2 #define MAXN 50001 3 using namespace std; 4 inline int read(){ 5 int a = 0; 6 char c = getchar(); 7 while(!isdigit(c)) 8 c = getchar(); 9 while(isdigit(c)) a += (a << 3) + a + (c ^ '0') , c = getchar(); 10 return a; 11 } 12 struct Edge{ 13 int end , upEd; 14 }Ed[MAXN << 1]; 15 struct node{ 16 int in , wei; 17 bool operator <(node a){return wei < a.wei;} 18 }Node[MAXN]; 19 int head[MAXN] , size[MAXN] , cnt[MAXN]; 20 int nowSize , N , K , minN , pos , cntEd , cntNode; 21 long long ans; 22 bool vis[MAXN]; 23 inline int max(int a , int b){return a > b ? a : b;} 24 25 inline void addEd(int a , int b){ 26 Ed[++cntEd].end = b; 27 Ed[cntEd].upEd = head[a]; 28 head[a] = cntEd; 29 } 30 inline void addNode(int a , int b){ 31 Node[++cntNode].in = a; 32 Node[cntNode].wei = b; 33 } 34 35 void getSize(int k){ 36 nowSize++; 37 vis[k] = 1; 38 for(int i = head[k] ; i ; i = Ed[i].upEd) 39 if(!vis[Ed[i].end]) 40 getSize(Ed[i].end); 41 vis[k] = 0; 42 } 43 44 void getZX(int k){ 45 int maxSize = 0; 46 size[k] = vis[k] = 1; 47 for(int i = head[k] ; i ; i = Ed[i].upEd) 48 if(!vis[Ed[i].end]){ 49 getZX(Ed[i].end); 50 maxSize = max(maxSize , size[Ed[i].end]); 51 size[k] += size[Ed[i].end]; 52 } 53 if(minN > (maxSize = max(maxSize , nowSize - size[k]))){ 54 minN = maxSize; 55 pos = k; 56 } 57 vis[k] = 0; 58 } 59 60 void dfs(int k , int in , int len){ 61 if(len > K) return; 62 addNode(in , len); 63 vis[k] = 1; 64 for(int i = head[k] ; i ; i = Ed[i].upEd) 65 if(!vis[Ed[i].end]) 66 dfs(Ed[i].end , in , len + 1); 67 vis[k] = 0; 68 } 69 70 void solve(int dir){ 71 nowSize = 0; 72 cntNode = 1; 73 minN = N + 1; 74 getSize(dir); 75 getZX(dir); 76 vis[pos] = 1; 77 int in = 0; 78 for(int i = head[pos] ; i ; i = Ed[i].upEd) 79 if(!vis[Ed[i].end]) 80 dfs(Ed[i].end , ++in , 1); 81 sort(Node + 1 , Node + cntNode + 1); 82 int l = 1 , r = cntNode , p = cntNode , count = 0; 83 bool f = 0; 84 while(l < r){ 85 if(l == 1 || Node[l].wei != Node[l - 1].wei){ 86 while(r > p) 87 cnt[Node[r--].in]--; 88 count = 0; 89 while(l < r && Node[l].wei + Node[r].wei > K) 90 r--; 91 if(l >= r) break; 92 p = r; 93 while(l < p && Node[l].wei + Node[p].wei == K){ 94 cnt[Node[p].in]++; 95 count++; 96 f = 1; 97 p--; 98 } 99 } 100 ans += count - cnt[Node[l].in]; 101 if(p == l){ 102 cnt[Node[++p].in]--; 103 count--; 104 } 105 l++; 106 } 107 for(int i = head[pos] ; i ; i = Ed[i].upEd) 108 if(!vis[Ed[i].end]) 109 solve(Ed[i].end); 110 } 111 int main(){ 112 N = read(); 113 K = read(); 114 for(register int i = 1 ; i < N ; ++i){ 115 int a = read() , b = read(); 116 addEd(a , b); 117 addEd(b , a); 118 } 119 solve(1); 120 cout << ans; 121 return 0; 122 }
再来一题:Tree
咦这题的等于$K$怎么变成小于等于$K$了
那么我们就不能使用桶了。而使用线段树等数据结构码量又会增大不少,我们可不可以用更优秀的方法解决呢?当然有。
每一次分治时,我们考虑将路径存下来,并按照长度从小到大排序,然后使用两个指针$L,R$来扫描路径数组并获取答案。
可以知道,当$L$在不断向右移动的时候,满足$len_L + len_R \leq K$的最大的$R$是单调递减的,所以可以直接调整$R$满足要求。调整了$R$之后,那么我们的答案就是$R-L$...
等等,我们没有考虑同一子树,所以我们还需要存下每一条路径的来源是哪一棵子树,用桶存好$L+1$到$R$之间每一个来源的数量,每一次$L$和$R$移动的时候维护这个桶,那么实际贡献的答案就是$R-L-\text{L+1到R中与L来源相同的路径的数量}$。
我们每一次分治的复杂度就是$O(\text{分治区域大小} log \text{分治区域大小})$的,总复杂度是$O(nlog^2n)$。如果写基数排序之类的东西的话复杂度就是$O(nlogn)$
代码在这里(之前把代码放成Race的了,现已Update)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 // luogu-judger-enable-o2
2 #include<bits/stdc++.h>
3 #define MAXN 40001
4 using namespace std;
5 struct Edge{
6 int end , w , upEd;
7 }Ed[MAXN << 1];
8 struct node{
9 int in , len;
10 }Node[MAXN];
11 int cntEd , cntNode , N , nowSize , minN , pos , ans , K;
12 int cnt[MAXN] , size[MAXN] , head[MAXN];
13 bool vis[MAXN];
14
15 inline bool cmp(node a , node b){return a.len < b.len;}
16
17 inline void add(int a , int b , int c){
18 Ed[++cntEd].w = c; Ed[cntEd].end = b;
19 Ed[cntEd].upEd = head[a]; head[a] = cntEd;
20 }
21
22 inline void pushNode(int len , int in){
23 Node[++cntNode].in = in; Node[cntNode].len = len; cnt[in]++;
24 }
25
26 inline int min(int a , int b){return a < b ? a : b;}
27 inline int max(int a , int b){return a > b ? a : b;}
28
29 void getSize(int k){
30 nowSize++;
31 vis[k] = 1;
32 for(int i = head[k] ; i ; i = Ed[i].upEd)
33 if(!vis[Ed[i].end]) getSize(Ed[i].end);
34 vis[k] = 0;
35 }
36
37 void findZX(int k){
38 int maxSize = 0;
39 vis[k] = size[k] = 1;
40 for(int i = head[k] ; i ; i = Ed[i].upEd)
41 if(!vis[Ed[i].end]){
42 findZX(Ed[i].end);
43 maxSize = max(maxSize , size[Ed[i].end]);
44 size[k] += size[Ed[i].end];
45 }
46 if(minN > (maxSize = max(maxSize , nowSize - size[k]))){
47 minN = maxSize;
48 pos = k;
49 }
50 vis[k] = 0;
51 }
52
53 void dfs(int k , int len , int in){
54 vis[k] = 1;
55 pushNode(len , in);
56 for(int i = head[k] ; i ; i = Ed[i].upEd)
57 if(!vis[Ed[i].end]) dfs(Ed[i].end , len + Ed[i].w , in);
58 vis[k] = 0;
59 }
60
61 void solve(int dir){
62 nowSize = cntNode = 0;
63 minN = N + 1;
64 getSize(dir);
65 findZX(dir);
66 pushNode(0 , 0);
67 cnt[0] = 0;
68 vis[pos] = 1;
69 int q = 0;
70 for(int i = head[pos] ; i ; i = Ed[i].upEd)
71 if(!vis[Ed[i].end]) dfs(Ed[i].end , Ed[i].w , ++q);
72 sort(Node + 1 , Node + cntNode + 1 , cmp);
73 int l = 1 , r = cntNode;
74 while(l < r){
75 while(Node[r].len + Node[l].len > K && l < r)
76 cnt[Node[r--].in]--;
77 if(l < r){
78 ans += r - l - cnt[Node[l].in];
79 cnt[Node[++l].in]--;
80 }
81 }
82 for(int i = head[pos] ; i ; i = Ed[i].upEd)
83 if(!vis[Ed[i].end]) solve(Ed[i].end);
84 }
85
86 int main(){
87 scanf("%d" , &N);
88 for(int i = 1 ; i < N ; i++){
89 int a , b , c;
90 scanf("%d%d%d" , &a , &b , &c);
91 add(a , b , c); add(b , a , c);
92 }
93 scanf("%d" , &K);
94 solve(1);
95 cout << ans;
96 return 0;
97 }
PS:因为Itst实在是太菜了,所以搞了好多次不晓得是$O(nlogn)$还是$O(nlog^2n)$,但实际上似乎是$O(nlog^2n)$的,因为分治式子是$T(n) = 2T(\frac{n}{2}) + O(nlogn)$,设$k = logn$,全部加起来有$T(n) = nlogn + 2\frac{n}{2}(logn - 1) + 4\frac{n}{4}(logn - 2) + ... + 2^k \frac{n}{2^k} (logn - k) = nlog^2n - nlogn = nlog^2n$
然后放几道练习题:
基础(比较裸就没有讲什么了):
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h>
2 #define MAXN 10001
3 using namespace std;
4 struct Edge{
5 int end , len , upEd;
6 }Ed[MAXN << 1];
7 struct node{
8 int in , len;
9 }Node[MAXN];
10 int size[MAXN] , N , head[MAXN] , pos , ans , cnt , nowSize , cntNode , num[MAXN];
11 bool vis[MAXN] , haveAns[10000000];
12
13 inline int min(int a , int b){return a < b ? a : b;}
14 inline int max(int a , int b){return a > b ? a : b;}
15
16 inline void add(int a , int b , int c){
17 Ed[++cnt].end = b; Ed[cnt].upEd = head[a]; Ed[cnt].len = c; head[a] = cnt;
18 }
19
20 inline void push_node(int len , int in){
21 Node[++cntNode].in = in; Node[cntNode].len = len;
22 }
23
24 void getSize(int k){
25 vis[k] = 1;
26 nowSize++;
27 for(int i = head[k] ; i ; i = Ed[i].upEd)
28 if(!vis[Ed[i].end]) getSize(Ed[i].end);
29 vis[k] = 0;
30 }
31
32 void findZX(int k){
33 int maxSize = 0;
34 vis[k] = size[k] = 1;
35 for(int i = head[k] ; i ; i = Ed[i].upEd)
36 if(!vis[Ed[i].end]){
37 findZX(Ed[i].end);
38 size[k] += size[Ed[i].end];
39 maxSize = max(maxSize , size[Ed[i].end]);
40 }
41 maxSize = max(maxSize , nowSize - size[k]);
42 if(ans > maxSize){
43 ans = maxSize;
44 pos = k;
45 }
46 vis[k] = 0;
47 }
48
49 void dfs(int k , int len , int in){
50 vis[k] = 1;
51 push_node(len , in);
52 for(int i = head[k] ; i ; i = Ed[i].upEd)
53 if(!vis[Ed[i].end]) dfs(Ed[i].end , len + Ed[i].len , in);
54 vis[k] = 0;
55 }
56
57 void solve(int dir){
58 ans = N + 1;
59 nowSize = cntNode = 0;
60 getSize(dir);
61 findZX(dir);
62 push_node(0 , 0);
63 vis[pos] = 1;
64 int cnt = 0;
65 for(int i = head[pos] ; i ; i = Ed[i].upEd)
66 if(!vis[Ed[i].end]) dfs(Ed[i].end , Ed[i].len , ++cnt);
67 for(int i = 1 ; i <= cntNode ; i++)
68 for(int j = i + 1 ; j <= cntNode ; j++)
69 if(Node[i].in != Node[j].in) haveAns[Node[i].len + Node[j].len] = 1;
70 for(int i = head[pos] ; i ; i = Ed[i].upEd)
71 if(!vis[Ed[i].end]) solve(Ed[i].end);
72 }
73
74 int main(){
75 int M;
76 scanf("%d%d" , &N , &M);
77 for(int i = 1 ; i < N ; i++){
78 int a , b , c;
79 scanf("%d%d%d" , &a , &b , &c);
80 add(a , b , c); add(b , a , c);
81 }
82 solve(1);
83 while(M--){
84 int K;
85 scanf("%d" , &K);
86 puts(haveAns[K] ? "AYE" : "NAY");
87 }
88 return 0;
89 }
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h>
2 #define MAXN 200001
3 using namespace std;
4 struct Edge{
5 int end , len , upEd;
6 }Ed[MAXN];
7 int N , cnt , in[3] , now[3] , nowSize , ans , pos , minN;
8 int head[MAXN] , size[MAXN];
9 bool vis[MAXN];
10
11 inline void add(int a , int b , int c){
12 Ed[++cnt].end = b; Ed[cnt].upEd = head[a]; Ed[cnt].len = c; head[a] = cnt;
13 }
14
15 inline int max(int a , int b){return a > b ? a : b;}
16
17 inline int gcd(int a , int b){
18 return a % b == 0 ? b : gcd(b , a % b);
19 }
20
21 void getSize(int k){
22 vis[k] = 1;
23 nowSize++;
24 for(int i = head[k] ; i ; i = Ed[i].upEd)
25 if(!vis[Ed[i].end]) getSize(Ed[i].end);
26 vis[k] = 0;
27 }
28
29 void findZX(int k){
30 int maxSize = 0;
31 vis[k] = size[k] = 1;
32 for(int i = head[k] ; i ; i = Ed[i].upEd)
33 if(!vis[Ed[i].end]){
34 findZX(Ed[i].end);
35 maxSize = max(maxSize , size[Ed[i].end]);
36 size[k] += size[Ed[i].end];
37 }
38 if(minN > (maxSize = max(maxSize , nowSize - size[k]))){
39 minN = maxSize;
40 pos = k;
41 }
42 vis[k] = 0;
43 }
44
45 void dfs(int k , int len){
46 now[len]++;
47 vis[k] = 1;
48 for(int i = head[k] ; i ; i = Ed[i].upEd)
49 if(!vis[Ed[i].end]) dfs(Ed[i].end , (len + Ed[i].len) % 3);
50 vis[k] = 0;
51 }
52
53 void solve(int dir){
54 nowSize = 0;
55 minN = N + 1;
56 getSize(dir);
57 findZX(dir);
58 in[0] = vis[pos] = 1;
59 now[1] = now[2] = now[0] = in[1] = in[2] = 0;
60 for(int i = head[pos] ; i ; i = Ed[i].upEd)
61 if(!vis[Ed[i].end]){
62 dfs(Ed[i].end , Ed[i].len % 3);
63 for(int j = 0 ; j < 3 ; j++)
64 ans += in[j] * now[(3 - j) % 3] * 2;
65 for(int j = 0 ; j < 3 ; j++){
66 in[j] += now[j];
67 now[j] = 0;
68 }
69 }
70 for(int i = head[pos] ; i ; i = Ed[i].upEd)
71 if(!vis[Ed[i].end]) solve(Ed[i].end);
72 }
73
74 int main(){
75 scanf("%d" , &N);
76 ans += N;
77 for(int i = 1 ; i < N ; i++){
78 int a , b , c;
79 scanf("%d%d%d" , &a , &b , &c);
80 add(a , b , c); add(b , a , c);
81 }
82 solve(1);
83 int t = gcd(N * N , ans);
84 cout << ans / t << '/' << N * N / t;
85 return 0;
86 }
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h>
2 #define MAXN 200001
3 #define ll long long
4 using namespace std;
5 inline ll read(){
6 ll a = 0;
7 char c = getchar();
8 bool f = 0;
9 while(!isdigit(c)){
10 if(c == '-') f = 1;
11 c = getchar();
12 }
13 while(isdigit(c)) a = (a << 3) + (a << 1) + (c ^ '0') , c = getchar();
14 return f ? -a : a;
15 }
16
17 struct Edge{
18 int end , w , upEd;
19 }Ed[MAXN << 1];
20 struct node{
21 int len , in;
22 ll wei;
23 }Node[MAXN];
24 int head[MAXN] , size[MAXN];
25 bool vis[MAXN];
26 int N , K , nowSize , minN , pos , ans , cntEd , cntNode;
27
28 bool cmp(node a , node b){return a.wei < b.wei;}
29
30 inline int max(int a , int b){return a > b ? a : b;}
31 inline int min(int a , int b){return a < b ? a : b;}
32
33 inline void addEd(int a , int b , ll c){
34 Ed[++cntEd].end = b; Ed[cntEd].w = c; Ed[cntEd].upEd = head[a]; head[a] = cntEd;
35 }
36
37 inline void addNode(int in , int len , ll wei){
38 Node[++cntNode].in = in; Node[cntNode].len = len;
39 Node[cntNode].wei = wei;
40 }
41
42 void getSize(int k){
43 nowSize++;
44 vis[k] = 1;
45 for(int i = head[k] ; i ; i = Ed[i].upEd)
46 if(!vis[Ed[i].end]) getSize(Ed[i].end);
47 vis[k] = 0;
48 }
49
50 void findZX(int k){
51 int maxSize = 0;
52 size[k] = vis[k] = 1;
53 for(int i = head[k] ; i ; i = Ed[i].upEd)
54 if(!vis[Ed[i].end]){
55 findZX(Ed[i].end);
56 maxSize = max(maxSize , size[Ed[i].end]);
57 size[k] += size[Ed[i].end];
58 }
59 if(ans > (maxSize = max(maxSize , nowSize - size[k]))){
60 ans = maxSize;
61 pos = k;
62 }
63 vis[k] = 0;
64 }
65
66 void dfs(int k , int in , int len , int w){
67 addNode(in , len , w);
68 vis[k] = 1;
69 for(int i = head[k] ; i ; i = Ed[i].upEd)
70 if(!vis[Ed[i].end]) dfs(Ed[i].end , in , len + 1 , w + Ed[i].w);
71 vis[k] = 0;
72 }
73
74 void solve(int k){
75 cntNode = nowSize = 0;
76 ans = 0x3f3f3f3f;
77 getSize(k);
78 findZX(k);
79 vis[pos] = 1;
80 addNode(0 , 0 , 0);
81 int cnt = 0;
82 for(register int i = head[pos] ; i ; i = Ed[i].upEd)
83 if(!vis[Ed[i].end]) dfs(Ed[i].end , ++cnt , 1 , Ed[i].w);
84 sort(Node + 1 , Node + cntNode + 1 , cmp);
85 register int l = 1 , r = cntNode;
86 while(l < r){
87 while(Node[l].wei + Node[r].wei > K && l < r) r--;
88 int p = r;
89 while(Node[l].wei + Node[p].wei == K && l < p){
90 if(Node[l].in != Node[p].in)
91 minN = min(minN , Node[l].len + Node[p].len);
92 p--;
93 }
94 l++;
95 }
96 for(register int i = head[pos] ; i ; i = Ed[i].upEd)
97 if(!vis[Ed[i].end]) solve(Ed[i].end);
98 }
99
100 int main(){
101 N = read(); K = read();
102 for(register int i = 1 ; i < N ; i++){
103 int a = read() , b = read();
104 ll c = read();
105 addEd(a , b , c); addEd(b , a , c);
106 }
107 minN = 0x3f3f3f3f;
108 solve(1);
109 cout << (minN == 0x3f3f3f3f ? -1 : minN);
110 return 0;
111 }
较难:(Solution更新中)
B.动态点分治(点分树)
什么?点分治还能带修改?Of course!
我们可以发现:根据点分治,我们可以构建出一棵树,在点分治过程中,如果从$solve(a)$递归到了$solve(b)$,就令$a$所在分治区域的重心为$b$所在分治区域重心的父亲,这样我们就可以构造出点分树。点分树有几个优美的性质:
$a.$点分树的高度不超过$O(logn)$,因为点分治的递归深度不会超过$logn$
$b.$点分树上某个点的祖先(包括它自己)在点分治时的分治范围必定包括了这个点,而其他点的分治范围一定不会包含这个点。
$c.$点分树上某个点的儿子一定在这一个点的分治范围的子树中(废话)
这个性质告诉我们:如果在点分树上进行修改,只需要修改它到根的一条链,修改点数不会多于$logn$。
我们就说$Qtree4$的做法吧,毕竟捉迷藏是边权为$1$的特殊版本。
我们构建好点分树,考虑如何在点分树上维护答案。我们需要支持插入、删除和查询最大值、次大值,考虑使用堆+懒惰堆思想进行维护。
我们对每一个点维护一个堆$heap1$,维护当前节点对应的分治范围内的路径的最大值和次大值。但我们又会面对与静态点分治一样的问题:可能来自当前节点的同一个子树的一条路径在当前节点贡献答案。所以我们对于每一个节点还要维护当前节点对应的分治范围内的路径到达当前节点在点分树上的父亲的路径长度的堆$heap2$,这样父亲在转移时就可以直接取它的所有儿子的$heap2$的最大值放入自己对应的$heap1$中,统计答案的时候把它的$heap2$的最大值从它的父亲的$heap1$中删掉,就可以避免了重复的计算。然后我们在全局维护一个堆$heap3$来维护全局的答案,每一次产生新的答案就进行维护。
那么我们每一次翻转一个节点的颜色的时候,就在点分树上暴跳父亲,并维护好$heap1,heap2,heap3$。初始化的时候也暴跳父亲。复杂度$O(nlog^2n)$,在$Qtree4$上有一些卡常,给出一种优化方式:在删除的时候,不要在懒惰堆中加入一个元素就尝试删除答案堆,而是在询问的时候进行,这样可以降低常数。
注意一个细节:如果某一个节点可以被计入路径中,在它对应的$heap2$中是需要插入两个$0$的(表示自己与自己匹配或者自己与儿子匹配),这样子的答案才是正确的。
代码
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h>
2 #define INF 0x3f3f3f3f
3 //This code is written by Itst
4 using namespace std;
5
6 inline int read(){
7 int a = 0;
8 bool f = 0;
9 char c = getchar();
10 while(c != EOF && !isdigit(c)){
11 if(c == '-')
12 f = 1;
13 c = getchar();
14 }
15 while(c != EOF && isdigit(c)){
16 a = (a << 3) + (a << 1) + (c ^ '0');
17 c = getchar();
18 }
19 return f ? -a : a;
20 }
21
22 const int MAXN = 100010;
23 struct Edge{
24 int end , upEd;
25 }Ed[MAXN << 1];
26 int head[MAXN] , fa[MAXN][20] , dis[MAXN][20] , dep[MAXN] , size[MAXN] , ST[21][MAXN << 1] , fir[MAXN] , logg2[MAXN << 1];
27 int nowSize , minSize , minInd , ts , N , cntEd;
28 bool vis[MAXN];
29 struct pq{
30 priority_queue < int > now , del;
31 inline void maintain(){
32 while(!del.empty() && del.top() == now.top()){
33 del.pop();
34 now.pop();
35 }
36 }
37 inline void push(int x){
38 now.push(x);
39 }
40 inline void pop(int x){
41 del.push(x);
42 maintain();
43 }
44 inline int top(){
45 return now.empty() ? -INF : now.top();
46 }
47 inline int sec(){
48 if(now.empty())
49 return -INF;
50 int t = now.top();
51 now.pop();
52 maintain();
53 int p = now.empty() ? -INF : now.top();
54 now.push(t);
55 return p;
56 }
57 }ans , cur[MAXN] , ch[MAXN];
58
59 inline void addEd(int a , int b){
60 Ed[++cntEd].end = b;
61 Ed[cntEd].upEd = head[a];
62 head[a] = cntEd;
63 }
64
65 void init_dfs(int now , int fa){
66 fir[now] = ++ts;
67 ST[0][ts] = now;
68 dep[now] = dep[fa] + 1;
69 for(int i = head[now] ; i ; i = Ed[i].upEd)
70 if(Ed[i].end != fa){
71 init_dfs(Ed[i].end , now);
72 ST[0][++ts] = now;
73 }
74 }
75
76 inline int cmp(int a , int b){
77 return dep[a] < dep[b] ? a : b;
78 }
79
80 void init_st(){
81 logg2[0] = -1;
82 for(int i = 1 ; i <= N << 1 ; ++i)
83 logg2[i] = logg2[i >> 1] + 1;
84 for(int i = 1 ; 1 << i <= N << 1 ; ++i)
85 for(int j = 1 ; j + (1 << i) - 1 <= N << 1 ; ++j)
86 ST[i][j] = cmp(ST[i - 1][j] , ST[i - 1][j + (1 << (i - 1))]);
87 }
88
89 inline int LCA(int x , int y){
90 x = fir[x];
91 y = fir[y];
92 if(x < y)
93 swap(x , y);
94 int t = logg2[x - y + 1];
95 return cmp(ST[t][y] , ST[t][x - (1 << t) + 1]);
96 }
97
98 void getSize(int x){
99 vis[x] = 1;
100 ++nowSize;
101 for(int i = head[x] ; i ; i = Ed[i].upEd)
102 if(!vis[Ed[i].end])
103 getSize(Ed[i].end);
104 vis[x] = 0;
105 }
106
107 void getRoot(int x){
108 vis[x] = size[x] = 1;
109 int maxN = 0;
110 for(int i = head[x] ; i ; i = Ed[i].upEd)
111 if(!vis[Ed[i].end]){
112 getRoot(Ed[i].end);
113 maxN = max(maxN , size[Ed[i].end]);
114 size[x] += size[Ed[i].end];
115 }
116 maxN = max(maxN , nowSize - size[x]);
117 if(maxN < minSize){
118 minSize = maxN;
119 minInd = x;
120 }
121 vis[x] = 0;
122 }
123
124 inline int getLen(int x , int y){
125 return dep[x] + dep[y] - (dep[LCA(x , y)] << 1);
126 }
127
128 int init_dfz(int x , int pre){
129 nowSize = 0;
130 minSize = INF;
131 getSize(x);
132 getRoot(x);
133 x = minInd;
134 vis[x] = 1;
135 fa[x][0] = pre;
136 for(int i = 0 , p = x ; fa[x][i] ; p = fa[x][i++]){
137 dis[x][i] = getLen(x , fa[x][i]);
138 fa[x][i + 1] = fa[fa[x][i]][0];
139 ch[p].push(dis[x][i]);
140 }
141 for(int i = head[x] ; i ; i = Ed[i].upEd)
142 if(!vis[Ed[i].end])
143 cur[x].push(ch[init_dfz(Ed[i].end , x)].top());
144 cur[x].push(0);
145 cur[x].push(0);
146 ans.push(cur[x].top() + cur[x].sec());
147 vis[x] = 0;
148 return x;
149 }
150
151 inline void init(){
152 init_dfs(1 , 0);
153 init_st();
154 init_dfz(1 , 0);
155 }
156
157 inline void modify(int x){
158 vis[x] ^= 1;
159 if(vis[x]){
160 ans.pop(cur[x].top() + cur[x].sec());
161 cur[x].pop(0);
162 cur[x].pop(0);
163 ans.push(cur[x].top() + cur[x].sec());
164 int p = x;
165 for(int i = 0 ; fa[x][i] ; p = fa[x][i++]){
166 ans.pop(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
167 cur[fa[x][i]].pop(ch[p].top());
168 ch[p].pop(dis[x][i]);
169 cur[fa[x][i]].push(ch[p].top());
170 ans.push(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
171 }
172 }
173 else{
174 ans.pop(cur[x].top() + cur[x].sec());
175 cur[x].push(0);
176 cur[x].push(0);
177 ans.push(cur[x].top() + cur[x].sec());
178 int p = x;
179 for(int i = 0 ; fa[x][i] ; p = fa[x][i++]){
180 ans.pop(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
181 cur[fa[x][i]].pop(ch[p].top());
182 ch[p].push(dis[x][i]);
183 cur[fa[x][i]].push(ch[p].top());
184 ans.push(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
185 }
186 }
187 }
188
189 inline int query(){
190 return ans.top() < 0 ? -1 : ans.top();
191 }
192
193 inline char getc(){
194 char c = getchar();
195 while(!isupper(c))
196 c = getchar();
197 return c;
198 }
199
200 int main(){
201 #ifndef ONLINE_JUDGE
202 freopen("2056.in" , "r" , stdin);
203 //freopen("2056.out" , "w" , stdout);
204 #endif
205 N = read();
206 for(int i = 1 ; i < N ; ++i){
207 int a = read() , b = read();
208 addEd(a , b);
209 addEd(b , a);
210 }
211 init();
212 for(int M = read() ; M ; --M)
213 if(getc() == 'G')
214 printf("%d\n" , query());
215 else
216 modify(read());
217 return 0;
218 }
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
1 #include<bits/stdc++.h>
2 #define INF 0x3f3f3f3f
3 //This code is written by Itst
4 using namespace std;
5
6 inline int read(){
7 int a = 0;
8 bool f = 0;
9 char c = getchar();
10 while(c != EOF && !isdigit(c)){
11 if(c == '-')
12 f = 1;
13 c = getchar();
14 }
15 while(c != EOF && isdigit(c)){
16 a = (a << 3) + (a << 1) + (c ^ '0');
17 c = getchar();
18 }
19 return f ? -a : a;
20 }
21
22 const int MAXN = 100010;
23 struct Edge{
24 int end , upEd , w;
25 }Ed[MAXN << 1];
26 int head[MAXN] , fa[MAXN][20] , dis[MAXN][20] , dep[MAXN] , size[MAXN] , ST[21][MAXN << 1] , fir[MAXN] , logg2[MAXN << 1] , l[MAXN];
27 int nowSize , minSize , minInd , ts , N , cntEd;
28 unsigned char vis[MAXN];
29 struct pq{
30 priority_queue < int > now , del;
31 inline void maintain(){
32 while(!del.empty() && del.top() == now.top()){
33 del.pop();
34 now.pop();
35 }
36 }
37 inline void push(int x){
38 now.push(x);
39 }
40 inline void pop(int x){
41 del.push(x);
42 }
43 inline int top(){
44 maintain();
45 return now.empty() ? -INF : now.top();
46 }
47 inline int sec(){
48 maintain();
49 if(now.empty())
50 return -INF;
51 int t = now.top();
52 now.pop();
53 maintain();
54 int p = now.empty() ? -INF : now.top();
55 now.push(t);
56 return p;
57 }
58 }ans , cur[MAXN] , ch[MAXN];
59
60 inline void addEd(int a , int b , int c){
61 Ed[++cntEd].end = b;
62 Ed[cntEd].upEd = head[a];
63 Ed[cntEd].w = c;
64 head[a] = cntEd;
65 }
66
67 void init_dfs(int now , int fa , int len){
68 fir[now] = ++ts;
69 ST[0][ts] = now;
70 dep[now] = dep[fa] + 1;
71 l[now] = len;
72 for(int i = head[now] ; i ; i = Ed[i].upEd)
73 if(Ed[i].end != fa){
74 init_dfs(Ed[i].end , now , len + Ed[i].w);
75 ST[0][++ts] = now;
76 }
77 }
78
79 inline int cmp(int a , int b){
80 return dep[a] < dep[b] ? a : b;
81 }
82
83 inline void init_st(){
84 logg2[0] = -1;
85 for(int i = 1 ; i <= N << 1 ; ++i)
86 logg2[i] = logg2[i >> 1] + 1;
87 for(int i = 1 ; 1 << i <= N << 1 ; ++i)
88 for(int j = 1 ; j + (1 << i) - 1 <= N << 1 ; ++j)
89 ST[i][j] = cmp(ST[i - 1][j] , ST[i - 1][j + (1 << (i - 1))]);
90 }
91
92 inline int LCA(int x , int y){
93 x = fir[x];
94 y = fir[y];
95 if(x < y)
96 swap(x , y);
97 int t = logg2[x - y + 1];
98 return cmp(ST[t][y] , ST[t][x - (1 << t) + 1]);
99 }
100
101 void getSize(int x){
102 vis[x] = 1;
103 ++nowSize;
104 for(int i = head[x] ; i ; i = Ed[i].upEd)
105 if(!vis[Ed[i].end])
106 getSize(Ed[i].end);
107 vis[x] = 0;
108 }
109
110 void getRoot(int x){
111 vis[x] = size[x] = 1;
112 int maxN = 0;
113 for(int i = head[x] ; i ; i = Ed[i].upEd)
114 if(!vis[Ed[i].end]){
115 getRoot(Ed[i].end);
116 maxN = max(maxN , size[Ed[i].end]);
117 size[x] += size[Ed[i].end];
118 }
119 maxN = max(maxN , nowSize - size[x]);
120 if(maxN < minSize){
121 minSize = maxN;
122 minInd = x;
123 }
124 vis[x] = 0;
125 }
126
127 inline int getLen(int x , int y){
128 return l[x] + l[y] - (l[LCA(x , y)] << 1);
129 }
130
131 int init_dfz(int x , int pre){
132 nowSize = 0;
133 minSize = INF;
134 getSize(x);
135 getRoot(x);
136 x = minInd;
137 vis[x] = 1;
138 fa[x][0] = pre;
139 for(int i = 0 , p = x ; fa[x][i] ; p = fa[x][i++]){
140 dis[x][i] = getLen(x , fa[x][i]);
141 fa[x][i + 1] = fa[fa[x][i]][0];
142 ch[p].push(dis[x][i]);
143 }
144 for(int i = head[x] ; i ; i = Ed[i].upEd)
145 if(!vis[Ed[i].end])
146 cur[x].push(ch[init_dfz(Ed[i].end , x)].top());
147 cur[x].push(0);
148 cur[x].push(0);
149 ans.push(cur[x].top() + cur[x].sec());
150 vis[x] = 0;
151 return x;
152 }
153
154 inline void init(){
155 init_dfs(1 , 0 , 0);
156 init_st();
157 init_dfz(1 , 0);
158 }
159
160 inline void modify(int x){
161 vis[x] ^= 1;
162 if(vis[x]){
163 ans.pop(cur[x].top() + cur[x].sec());
164 cur[x].pop(0);
165 cur[x].pop(0);
166 ans.push(cur[x].top() + cur[x].sec());
167 int p = x;
168 for(int i = 0 ; fa[x][i] ; p = fa[x][i++]){
169 ans.pop(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
170 cur[fa[x][i]].pop(ch[p].top());
171 ch[p].pop(dis[x][i]);
172 cur[fa[x][i]].push(ch[p].top());
173 ans.push(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
174 }
175 }
176 else{
177 ans.pop(cur[x].top() + cur[x].sec());
178 cur[x].push(0);
179 cur[x].push(0);
180 ans.push(cur[x].top() + cur[x].sec());
181 int p = x;
182 for(int i = 0 ; fa[x][i] ; p = fa[x][i++]){
183 ans.pop(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
184 cur[fa[x][i]].pop(ch[p].top());
185 ch[p].push(dis[x][i]);
186 cur[fa[x][i]].push(ch[p].top());
187 ans.push(cur[fa[x][i]].top() + cur[fa[x][i]].sec());
188 }
189 }
190 }
191
192 inline void query(){
193 if(ans.top() <= -INF)
194 puts("They have disappeared.");
195 else
196 printf("%d\n" , ans.top());
197 }
198
199 inline char getc(){
200 char c = getchar();
201 while(!isupper(c))
202 c = getchar();
203 return c;
204 }
205
206 int main(){
207 #ifndef ONLINE_JUDGE
208 freopen("4115.in" , "r" , stdin);
209 freopen("4115.out" , "w" , stdout);
210 #endif
211 N = read();
212 for(int i = 1 ; i < N ; ++i){
213 int a = read() , b = read() , c = read();
214 addEd(a , b , c);
215 addEd(b , a , c);
216 }
217 init();
218 for(int M = read() ; M ; --M)
219 if(getc() == 'A')
220 query();
221 else
222 modify(read());
223 return 0;
224 }
可以发现我们在上面维护了一个当前节点到它的父亲的一个堆,实际上这一种维护父亲的思想在点分树上经常会发挥很大作用,下一道题中我们也需要用到它。
点分树不仅擅长静态点分治擅长的路径拼接的操作,还擅长静态树上的动态换根统计
看下面这道题:幻想乡战略游戏
这道题简单来讲就是要求树上的带权重心,需要支持修改某个点的权值。
我们先来考虑每一次操作过后通过移动来维护带权重心。我们考虑将当前重心从一个点$x$移到它的一个儿子$y$上。我们不妨设$sum_i$表示$i$所在子树的权值和,那么我们移动产生的代价就是$delta = (sum_{root} - sum_y - sum_y) \times dis(x , y)$
那么如果说$sum_y \times 2 > sum_{root}$,意味着$delta < 0$,也就是说移动之后会更优。而显然对于某一个节点$x$来说,这样子的儿子$y$至多只有一个,如果没有就表示$x$是最优的答案了。
也就是说在每一次询问中,我们实际上可以任选一个点,然后通过$sum$的限制将重心移动,直到移动到最优的地方。
但是如果暴力去做的话,复杂度最坏是$O(n)$的。我们可以使用点分治的思想(上面练习题中“邮递员”一题就使用了这个思想),每一次如果找到一个最优的方向,就跳到对应子树的重心再去做,这样子就是$O(logn)$了。这一种操作就相当于在点分树上寻找一条路径。
然而在动态修改权的时候$sum$并不好维护,我们考虑维护以某一个点为根时的答案,比较两个点之间的答案大小来判断是否移动,实质和上面的分析是一样的。
我们对于点分树上每一个点,维护这三个东西:
$sumD:$当前点对应的分治范围的权值和
$sumV:$当前点对应的分治范围到达分治中心的代价总和
$upV:$当前点对应的分治范围到达分治中心的父亲的代价总和(维护父亲思想体现!)
然后考虑如何维护一个点的答案,直接看代码和注释吧
int sum = sumV[x] , p = x;
//答案初始化为所有子树的答案
while(fa[x]){
sum += sumV[fa[x]] - upV[x];
//祖先的其他子树到达这个祖先的答案
sum += (sumD[fa[x]] - sumD[x]) * calcLen(p , fa[x]);
//祖先的其他子树从祖先走到当前节点额外需要经过的路程,其中calcLen(x,y)表示计算x和y之间的距离
x = fa[x];
}
return sum;
这样我们只需要维护$sumV,upV,sumD$就能维护某一个点的答案了。这三个按照套路在每一次修改时暴跳点分树上父亲即可。
那么我们的$query$就可以这样进行:首先选择点分树上的根作为重心,$for$其点分树上的儿子,计算这个儿子所在子树的根的答案(注意不是这个儿子的答案),如果比当前更小就转移到点分树上的这个儿子,递归处理。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
// luogu-judger-enable-o2
#include<bits/stdc++.h>
#define INF 0x7fffffff
#define int long long
//This code is written by Itst
using namespace std;
inline int read(){
int a = 0;
bool f = 0;
char c = getchar();
while(c != EOF && !isdigit(c)){
if(c == '-')
f = 1;
c = getchar();
}
while(c != EOF && isdigit(c)){
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 100010;
struct Edge{
int end , upEd , len;
}Ed[MAXN << 1];
int head[MAXN] , fa[MAXN] , size[MAXN] , sumD[MAXN] , sumV[MAXN] , upV[MAXN] , up[MAXN];
int ST[21][MAXN << 1] , fir[MAXN] , logg2[MAXN << 1] , len[MAXN] , dep[MAXN];
int N , M , cntEd , nowSize , minSize , minInd , ts , root;
vector < int > ch[MAXN];
bool vis[MAXN];
inline void addEd(int a , int b , int c){
Ed[++cntEd].end = b;
Ed[cntEd].upEd = head[a];
Ed[cntEd].len = c;
head[a] = cntEd;
}
void getSize(int x){
vis[x] = 1;
++nowSize;
for(int i = head[x] ; i ; i = Ed[i].upEd)
if(!vis[Ed[i].end])
getSize(Ed[i].end);
vis[x] = 0;
}
void getRoot(int x){
size[x] = vis[x] = 1;
int maxN = 0;
for(int i = head[x] ; i ; i = Ed[i].upEd)
if(!vis[Ed[i].end]){
getRoot(Ed[i].end);
size[x] += size[Ed[i].end];
maxN = max(maxN , size[Ed[i].end]);
}
maxN = max(maxN , nowSize - size[x]);
if(maxN < minSize){
minSize = maxN;
minInd = x;
}
vis[x] = 0;
}
int init_dfz(int x , int f){
int p = x;
nowSize = 0;
minSize = INF;
getSize(x);
getRoot(x);
x = minInd;
up[x] = p;
fa[x] = f;
vis[x] = 1;
for(int i = head[x] ; i ; i = Ed[i].upEd)
if(!vis[Ed[i].end])
ch[x].push_back(init_dfz(Ed[i].end , x));
vis[x] = 0;
return x;
}
void init_dfs(int x , int p , int l){
dep[x] = dep[p] + 1;
ST[0][++ts] = x;
fir[x] = ts;
len[x] = l;
for(int i = head[x] ; i ; i = Ed[i].upEd)
if(!dep[Ed[i].end]){
init_dfs(Ed[i].end , x , l + Ed[i].len);
ST[0][++ts] = x;
}
}
inline int cmp(int x , int y){
return dep[x] < dep[y] ? x : y;
}
void init_st(){
for(int i = 2 ; i <= N << 1 ; ++i)
logg2[i] = logg2[i >> 1] + 1;
for(int i = 1 ; 1 << i <= N << 1 ; ++i)
for(int j = 1 ; j + (1 << i) <= N << 1 ; ++j)
ST[i][j] = cmp(ST[i - 1][j] , ST[i - 1][j + (1 << (i - 1))]);
}
void init(){
root = init_dfz(1 , 0);
init_dfs(1 , 0 , 0);
init_st();
}
inline int LCA(int x , int y){
x = fir[x];
y = fir[y];
if(y < x)
swap(x , y);
int t = logg2[y - x + 1];
return cmp(ST[t][x] , ST[t][y - (1 << t) + 1]);
}
inline int calcLen(int x , int y){
return len[x] + len[y] - (len[LCA(x , y)] << 1);
}
inline int calc(int x){
int sum = sumV[x] , p = x;
while(fa[x]){
sum += sumV[fa[x]] - upV[x];
sum += (sumD[fa[x]] - sumD[x]) * calcLen(p , fa[x]);
x = fa[x];
}
return sum;
}
int query(int x){
int nowans = calc(x);
for(int i = 0 ; i < ch[x].size() ; ++i)
if(calc(up[ch[x][i]]) < nowans)
return query(ch[x][i]);
return nowans;
}
inline int modify(int x , int num){
sumD[x] += num;
int p = x;
while(fa[x]){
sumD[fa[x]] += num;
upV[x] += num * calcLen(p , fa[x]);
sumV[fa[x]] += num * calcLen(p , fa[x]);
x = fa[x];
}
return query(root);
}
signed main(){
#ifndef ONLINE_JUDGE
freopen("3345.in" , "r" , stdin);
//freopen("3345.out" , "w" , stdout);
#endif
N = read();
M = read();
for(int i = 1 ; i < N ; ++i){
int a = read() , b = read() , c = read();
addEd(a , b , c);
addEd(b , a , c);
}
init();
for(int i = 1 ; i <= M ; ++i){
int x = read() , y = read();
printf("%lld\n" , modify(x , y));
}
return 0;
}
这道题可能不是很好理解。
最后放几道练习题:(Solution更新中)
C.总结
点分治是一种通过选择树的重心,将原树剖成若干子树递归处理的一种树分治,擅长路径统计,而将点分治的遍历顺序建成树,就成为了点分树,因为点分树有高度不超过$log$的性质,所以可以在点分树上暴跳维护动态点分治,不仅可以处理路径统计,还可以处理换根统计问题,是一种很板子又很灵活的算法。
其实就是把前面的话抄了一遍