树链剖分的一种妙用与一类树链修改单点查询问题的时间复杂度优化——2018ACM陕西邀请赛J题

题目描述

有一棵树，每个结点有一个灯（初始均是关着的）。每个灯能对该位置和相邻结点贡献1的亮度。现有两种操作：

（1）将一条链上的灯状态翻转，开变关、关变开；

（2）查询一个结点的亮度。

数据规模：\(1 \le n,q \le 10^5\)

简要题解

对于这种题，很容易想到任意指定一个根转化为有根树，每个结点维护值\(a_i\)表示它的所有儿子的贡献之和，这样再加上自己以及父亲的贡献就能回答一个询问了。

然而经过一波思考发现问题在于链修改时根本没法维护\(a_i\)。因此需要用链修改时的常规操作——树链剖分理论来解决本题了。

对于树链剖分，每一条链被剖分成了\(O(\log n)\)条重链，下面考虑修改每条重链\((s,t)\)，不妨设\(depth[s]<depth[t]\)。可以发现修改后只会改变\((father[s],father[t])\)这条链上的\(a_i\)，但是注意到链\((s,father[t])\)上每个结点都是它父亲的重儿子，如果我们\(a_i\)不维护重儿子，让\(a_i\)表示它的所有轻儿子的贡献之和，那么每条重链只需暴力修改一个\(a_{father[s]}\)。这样对于每个修改，更新\(a\)数组的时间复杂度为\(O(\log n)\)；同时当然还需要更新链上灯的状态，即进行链异或1的操作，如果采用树链剖分加树状数组可达到\(O(\log ^2 n)\)的时间复杂度。对于每个询问\(x\)，只需要查询\(a_x\)（对应轻儿子），以及\(father[x],x,son[x]\)（分别对应父亲、重儿子、自身）的状态即可（这里\(son[x]\)表示\(x\)的重儿子），查询时间复杂度\(O(\log n)\)。

总时间复杂度\(O(n+q \log ^2 n)\)。（PS：感谢队友ddd教我这么巧的方法！）

进一步的改进

这一做法虽然很巧妙，但是其唯一的瓶颈\(O(\log ^2 n)\)为树状数组修改，其它所有操作（无论\(a_i\)修改还是树状数组查询）均为\(O(\log n)\)，显得很不协调（强迫症患者的我当然不舒服了）。针对本题链上异或单点查询问题，这里再给出一个更为高效的做法。

构造一个DFS序列，对每棵子树\(i\)，序列定义为\(i\)开头，然后是\(i\)的每棵子树的DFS序列依次拼起来，最后\(i\)结尾，这样序列总长度为\(2n\)。设\(h_1[i]\)和\(h_2[i]\)分别为\(i\)第一次和第二次在序列中出现的位置。维护一个长为\(2n\)的数组\(b\)，对于每次链\((x,y)\)异或1，执行如下算法：

（1）将\(b[h_2[x]]\)到\(b[2n]\)全部异或1；

（2）将\(b[h_2[y]]\)到\(b[2n]\)全部异或1；

（3）将\(b[h_2[lca(x,y)]]\)异或1。

定理：对于上述算法，每次单点查询\(x\)时，只需求\(b[h_1[x]] \oplus b[h_2[x]]\)即为答案。

为证明该定理，首先证明以下引理：

引理1：若结点\(t\)是结点\(x\)的祖先（可以是自身），当且仅当\(h_1[t] \le h_1[x]\)且\(h_2[t] \ge h_2[x]\)。

根据DFS序列的定义，证明显然。

引理2：对于结点\(x\)，将\(b[h_2[x]]\)到\(b[2n]\)全部异或1后，只有\(x\)祖先\(t\)（包括自身）的\(b[h_1[t]] \oplus b[h_2[t]]\)值改变；

证明：首先证明充分性。若结点\(t\)是结点\(x\)的祖先，根据引理1，\(b[h_1[t]]\)不变，\(b[h_2[t]]\)异或了1，正确；

接下来证明必要性。若结点\(t\)不是结点\(x\)的祖先，根据引理1，分三种情况：

情况1：\(h_1[t] \le h_1[x]\)且\(h_2[t] < h_2[x]\)，此时\(b[h_1[t]]\)和\(b[h_2[t]]\)均不变；

情况2：\(h_1[t] > h_1[x]\)且\(h_2[t] \ge h_2[x]\)，此时必有\(h_1[t] > h_2[x]\)。若不然，根据\(h_2[x] \gt h_1[t]\)以及\(h_2[x] \le h_2[t]\)可知\(t\)是\(x\)的祖先，根据引理1，这与 \(h_1[t] > h_1[x]\)矛盾。因此\(b[h_1[t]]\)和\(b[h_2[t]]\)均异或了1；

情况3：\(h_1[t] > h_1[x]\)且\(h_2[t] < h_2[x]\)，由于\(h_1[t] < h_2[t]\)，故\(h_1[t] < h_2[x]\)，此时\(b[h_1[t]]\)和\(b[h_2[t]]\)均不变。

以上三种情况\(b[h_1[t]] \oplus b[h_2[t]]\)均不变，必要性证毕。事实上，以上三种情况画图恰好对应了\(x\)左侧结点、\(x\)右侧结点和\(x\)的子树。

定理证明：根据引理2易得。

实现时，只需维护树状数组即可，每次链修改的时间复杂度为\(O(\log n)\)。这样整个题目的时间复杂度便被优化到了\(O(n+q \log n)\)，已经达到了时间复杂度的极限，不可能再优了。

事实上，上述方法做出适当的修改可用于树上链加，单点求和的情形。广义来说，只要运算构成一个群，都可以用此方法优化时间复杂度。

AC代码

以下代码是改进之前的，更好写一些。

 #include<cstdio>
 #include<cstring>
 #include<vector>
 using namespace std;
 vector<int> v[];
 int father[], depth[], top[], id[], son[];
 int cnt;
 int dfs1(int i, int fa)
 {
     father[i] = fa;
     depth[i] = depth[fa] + ;
     son[i] = ;
     int ret = , maxSize = ;
     for (unsigned int j = ; j < v[i].size(); j++){
         int t = v[i][j];
         if (t == fa)continue;
         int size = dfs1(t, i);
         ret += size;
         if (size > maxSize){
             maxSize = size;
             son[i] = t;
         }
     }
     return ret + ;
 }
 void dfs2(int i, int tp)
 {
     top[i] = tp;
     id[i] = ++cnt;
     if (son[i])dfs2(son[i], tp);
     for (unsigned int j = ; j < v[i].size(); j++){
         int t = v[i][j];
         if (t != father[i] && t != son[i])dfs2(t, t);
     }
 }
 void init()
 {
     cnt = ; depth[] = ;
     dfs1(, ); dfs2(, );
 }

 bool tree[];
 int light[], treeLen;
 int sum(int i)
 {
     int ret = ;
     for (; i > ; i -= i&-i)ret ^= tree[i];
     return ret;
 }
 void flip(int i)
 {
     for (; i <= treeLen; i += i&-i)
         tree[i] ^= ;
 }
 void modify(int s, int t)
 {
     int top1 = top[s], top2 = top[t];
     while (top1 != top2){
         if (depth[top1] < depth[top2]){
             flip(id[top2]); flip(id[t] + );
             t = father[top2];
             if (son[t] != top2)light[t] += sum(id[top2]) ?  : -;
             top2 = top[t];
         }
         else{
             flip(id[top1]); flip(id[s] + );
             s = father[top1];
             if (son[s] != top1)light[s] += sum(id[top1]) ?  : -;
             top1 = top[s];
         }
     }
     if (depth[s] > depth[t])swap(s, t);
     flip(id[s]); flip(id[t] + );
     if (son[father[s]] != s)light[father[s]] += sum(id[s]) ?  : -;
 }
 int main()
 {
     int n, m, x, y, z;
     scanf("%d%d", &n, &m);
     for (int i = ; i < n; i++){
         scanf("%d%d", &x, &y);
         v[x].push_back(y);
         v[y].push_back(x);
     }
     init(); treeLen = n;
     while (m--){
         scanf("%d", &z);
         if (z == ){
             scanf("%d%d", &x, &y);
             modify(x, y);
         }
         else{
             scanf("%d", &x);
             int ans = father[x] ? sum(id[father[x]]) : ;
             if (son[x])ans += sum(id[son[x]]);
             ans += sum(id[x]) + light[x];
             printf("%d\n", ans);
         }
     }
 }