bestcoder round#45 1003 题，给定两个点，要我们求这两个点的树上路径所经过的点的权值是否出现过奇数次。
如果是一般人，那么就是用lca求树上路径，然后判断是否出现过奇数次（用异或），高手就不这么做了，直接树链剖分。
为什么不能用lca，因为如果有树退化成链，那么每次询问的复杂度是O(n)， 那么q次询问的时间复杂度是O(qn)
什么是树链剖分呢？ 就是把树的边分成轻链和重链
http://blogsina
.com.cn/s/blog_6974c8b20100zc61.html
http://wwwcnblogs.com/BLADEVIL/p/3479713.html
这两个博客写的很好了
剖分后的树有如下性质：
1、如果（u，v)为轻边， 那么 size[v]*2<size[u]
2、从根到某一点的路径上的轻链，重链的个数不大于logn
所以我们可以用线段树来维护这些链，这样如果 要得到任意两点树上路径的信息，那么只要访问线段树，那么时间复杂度只要4logn*logn
第一次dfs进行树链剖分，求出了轻链和重链
第二次dfs对树的结点进行了重新编号（结点的编号就是在线段树中区间中的一点）， 重链上的结点的编号是连续的
那么重链上的点在线段树中的区间是连续的。
那么要询问树上任意两点路径权值的最大值， 只要上depth大的那个点往上走， 如果往上走的时候，遇到的重链，那么可以进去区间查询，然后一次
走过重链即可。
对于bestcoder round#45 1003 题，
第二次dfs求出编号后，建线段树，然后区间的值等于子区间的异或
那么任意两点的树上路径的权值是否重复，只要访问线段树区间，看最后的异或的值是为0
1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <algorithm>
5 #include <iostream>
6 #include <queue>
7 #include <stack>
8 #include <vector>
9 #include <map>
10 #include <set>
11 #include <string>
12 #include <math.h>
13 using namespace std;
14 #pragma comment(linker, "/STACK:1024000000,1024000000")
15 #pragma warning(disable:4996)
16 typedef long long LL;
17 const int INF = 1<<30;
18 void input(int &x)
19 {
20 char ch = getchar();
21 while (ch<‘0‘ || ch>‘9‘)
22 ch = getchar();
23 x = 0;
24 while (ch >= ‘0‘&&ch <= ‘9‘)
25 {
26 x = x * 10 + ch - ‘0‘;
27 ch = getchar();
28 }
29 }
30 /*
31 第一次dfs进行树链剖分，求出了轻链和重链
32 第二次dfs对树的结点进行了重新编号， 重链上的结点的编号是连续的
33 那么重链上的点在线段树中的区间是连续的
34 剖分后的树有如下性质：
35 性质1：如果(v,u)为轻边，则siz[u] * 2 < siz[v]；
36 性质2：从根到某一点的路径上轻链、重链的个数都不大于logn。
37
38 那么要询问树上任意两点路径权值的最大值， 只要上depth大的那个点往上走， 如果往上走的时候，遇到的重链，那么可以进去区间查询，然后一次
39 走过重链
40 根据性质2：每次询问的复杂度是O(logn*logn)
41 */
42 const int N = 100000 + 10;
43 int size[N], depth[N], son[N], fa[N], w[N], top[N], ra[N], num;
44 int value[N];
45 int tree[N * 4];
46 vector<int> g[N];
47 int ans;
48 void dfs(int u)
49 {
50 size[u] = 1;
51 son[u] = 0;
52 for (int i = 0; i < g[u].size(); ++i)
53 {
54 int v = g[u][i];
55 if (v != fa[u])
56 {
57 depth[v] = depth[u] + 1;
58 fa[v] = u;
59 dfs(v);
60 size[u] += size[v];
61 if (size[v]>size[son[u]])
62 son[u] = v;
63 }
64 }
65 }
66 void dfs2(int u, int tp)
67 {
68 top[u] = tp;
69 w[u] = ++num;//对树上的结点进行编号
70 ra[num] = u;
71 //因为优先dfs重儿子，所以一条重链上的点的编号是连续的
72 if (son[u] != 0)
73 dfs2(son[u], top[u]);
74 for (int i = 0; i < g[u].size(); ++i)
75 {
76 int v = g[u][i];
77 if (v != son[u] && v != fa[u])
78 dfs2(v, v);
79 }
80 }
81 void pushUp(int rt)
82 {
83 tree[rt] = tree[rt << 1] ^ tree[rt << 1 | 1];
84 }
85 void build(int l, int r, int rt)
86 {
87 if (l == r)
88 {
89 tree[rt] = value[ra[l]];//ra[l] 是编号为l的是哪个结点
90 return;
91 }
92 int mid = (l + r) >> 1;
93 build(l, mid, rt << 1);
94 build(mid + 1, r, rt << 1 | 1);
95 pushUp(rt);
96 }
97 //修改某个结点的值， 那么要将父区间异或旧的值（即去除原先的值），然后异或新的值
98 void update(int l, int r, int rt, int pos, int newVal, int oldVal)
99 {
100 tree[rt] = tree[rt] ^ oldVal^newVal;
101 if (l == r)
102 return;
103 int mid = (l + r) >> 1;
104 if (pos <= mid)
105 update(l, mid, rt << 1, pos, newVal, oldVal);
106 else
107 update(mid + 1, r, rt << 1 | 1, pos, newVal, oldVal);
108 }
109 void query(int l, int r, int rt, int L, int R)
110 {
111 if (L <= l && R >= r)
112 {
113 ans ^= tree[rt];
114 return;
115 }
116 int mid = (l + r) >> 1;
117 if (L <= mid)
118 query(l, mid, rt << 1, L, R);
119 if (R > mid)
120 query(mid + 1, r, rt << 1 | 1, L, R);
121 }
122 int main()
123 {
124 int t, n, q, op,a, b;
125 scanf("%d", &t);
126 while (t--)
127 {
128 num = 0;
129 scanf("%d%d", &n, &q);
130 for (int i = 1; i <= n; ++i)
131 g[i].clear();
132 for (int i = 1; i < n; ++i)
133 {
134 scanf("%d%d", &a, &b);
135 g[a].push_back(b);
136 g[b].push_back(a);
137 }
138 for (int i = 1; i <= n; ++i)
139 {
140 //scanf("%d", &value[i]);
141 input(value[i]);
142 value[i]++;
143 }
144 depth[1] = fa[1] = 0;
145 dfs(1);
146 dfs2(1, 1);
147 build(1, n, 1);
148 while (q--)
149 {
150 scanf("%d%d%d", &op, &a, &b);
151
152 if (op == 0)
153 {
154 b++;
155 update(1, n, 1, w[a], b, value[a]);
156 value[a] = b;
157 }
158 else
159 {
160 ans = 0;
161 //不停的往上走，像lca一样，不过比lca更优，因为有重链的存在，可以一次走很多部
162 while (top[a] != top[b])
163 {
164 if (depth[top[a]] < depth[top[b]])
165 swap(a, b);
166 query(1, n, 1, w[top[a]], w[a]);
167 a = fa[top[a]];
168 }
169 if (depth[a] > depth[b])
170 swap(a, b);
171 query(1, n, 1, w[a], w[b]);
172 if (ans == 0)
173 printf("%d\n", -1);
174 else
175 printf("%d\n", ans - 1);
176 }
177 }
178 }
179 return 0;
180 }
时间： 2024-10-25 12:09:47