第三种树链剖分: 长链剖分

长链剖分

树链剖分可以分为三种, 分别是重链剖分, 动态树 (实链剖分) 和长链剖分 (Long Path Decomposition).

长链剖分的规则是将子树包含最深的后代的儿子设为 "长儿子", 然后将到长儿子的边称 "长边", 长边组成的链称 "长链", 其余的边都是 "短边". 和重链剖分类似, 长链的长度定义为它包含的节点数, 或是长边数 $+1$.

前两种剖分方式, 在绝大多数题目中可以相互代替, 但是长链剖分的应用却和它们不同.

路径短边数量

考虑如何使用最少的节点数, 构造一棵树, 让它在长链剖分后, 根到某个叶子的路径上, 短边数量最多.

依然是重链剖分的构造方式, 从边界情况开始考虑:

• 根到叶子最多有 $0$ 个短边, 最少需要 $0$ 个点.

连点都不用就构造完了, 没什么好解释的.

• 根到叶子最多有 $1$ 个短边, 最少需要 $3$ 个点.

一个根, 左右儿子都是单点, 这时, 两个儿子必有一个是长儿子, 另一个是短儿子, 有一个短边.

• 根到叶子最多有 $2$ 个短边, 最少需要 $6$ 个点.

在上一棵树的基础上, 在根上接一个父亲作为新的根, 在这个根下面接一个长度为 $2$ 的垂直的链作为长链, 则旧根可以做新根的短儿子.

• 根到叶子最多有 $k$ 个短边, 最少需要 $\frac {(k + 1)(k + 2)}2$ 个点.

发现以这种构造方式, 每次可以从根到叶子最多 $k - 1$ 个短边的树的基础上, 接一个根节点, 再接一条长度为 $k - 1$ 的长链. 这样, 所需的点数便成了等差数列求和, 所以得到式子 $\frac {(k + 1)(k + 2)}2$.

举个例子, 这是一棵到叶子最多有 $3$ 个短边的树, 短边分别是: 6-3, 3-2, 2-0.

因此, 对于一棵 $n$ 个节点的树, 根到叶子路径上最多的短边数量为 $O(\sqrt n)$.

主要应用: $O(1)$ 求树上第 $k$ 级祖先

由于长链剖分的特殊性质: 一个长链链顶的子树的深度就是这个长链的长度. 所以可以保证一个点 $x$ 的 $a$ 级祖先所在的长链长度至少有 $a$. 这个结论很好证明, 只要假设这个长链长度小于 $a$, 则 $x$ 点到它的 $a$ 级祖先的路径必然是长度为 $a$ 的长链.

对于剖分后的每个点, 分配一个 DFS 序, 保证在长链上的相邻的点的 DFS 序相邻.

对于一棵 $n$ 个点的树, 可以建立一个长度为 $n$ 的数组 $List$, 对于每个长链, 设它的长度为 $l$ 设它链顶的 DFS 序为 $x$, 则 $List$ 的第 $[x, x + l)$ 的位置, 依次存 $x$ 的第 $[0, l)$ 级祖先.

再记录一个数组 $InList$, 使得 $InList_i$ 表示 DFS 序为 $i$ 的点的编号. 因为长链剖分的性质, 对于一个长链链顶 $x$ (它的 DFS 序为 $x$), $InList$ 的第 $[x, x + l)$ 位表示它的 $[0, l)$ 级长链上后代.

接下来, 和倍增求 LCA 一样, 求每个节点的 $2^a$ 级祖先, 预处理复杂度 $O(nlogn)$.

另外要提前预处理对于 $i \in [1, n]$ 的 $\lfloor \log_2 i \rfloor$.

这时查询任意点 $x$ 的第 $k$ 级祖先, 首先 $O(1)$ 找到 $x$ 的第 $2^i$ 祖先 $Anc$ 满足 $2^i \leq k < 2^{i + 1}$.

这时, 可以保证 $Anc$ 所在的长链长度至少为 $2^i$. 而因为 $k < 2^{i + 1}$, 所以 $k - 2^i < 2^i$, 这时分类讨论:

• 目标在 $Anc$ 所在的长链上

  这时 $O(1)$ 查询 $Anc$ 链顶的 $InList$ 数组即可.

• 目标在 $Anc$ 所在的长链顶之上

  所以目标一定在 $Anc$ 链顶的 $List$ 中可以 $O(1)$ 查询.

实现

长链剖分和重链剖分类似, 分两次 DFS, 求出所需的几个值. 本题需要初始化几个数组, 然后 $O(1)$ 回答询问即可.

unsigned Seed, Log[500005], Bin[20], Hd(0), List[500005], InList[500005], m, n, Cnt(0), A, B, C, D, t, Ans(0), Tmp(0);
inline unsigned Rand(unsigned x) {
	x ^= x << 13, x ^= x >> 17, x ^= x << 5;return Seed = x;
}
unsigned long long Prt(0);
char Short(1);
struct Node {
  Node *Fa[20], *Son, *Bro, *LonSon, *Top;
  unsigned Len, DFSr, Deep;
}N[500005], *Root, *Top[500005];
void Link(Node *x, Node *y) {
  y->Bro = x->Son, x->Son = y;
}
void DFS1(Node *x) {
  Node *now(x->Son);
  x->Len = 1;
  while(now) {
    now->Deep = x->Deep + 1;
    now->Fa[0] = x;
    for (register unsigned i(0); now->Fa[i]; ++i) {
      now->Fa[i + 1] = now->Fa[i]->Fa[i];
    }
    DFS1(now);
    if(now->Len + 1 > x->Len) {
      x->Len = now->Len + 1;
      x->LonSon = now;
    }
    now = now->Bro;
  }
}
void DFS2(Node *x) {
  if(Short) Top[++Hd] = x, x->Top = x;
  Node *now(x->Son);
  x->DFSr = ++Cnt;
  InList[Cnt] = x - N;
  if(x->LonSon) {
    Short = 0;
    x->LonSon->Top = x->Top;
    DFS2(x->LonSon);
    Short = 1;
  }
  while(now) {
    if(now != x->LonSon) {
      DFS2(now);
    }
    now = now->Bro;
  }
}
signed main() {
  n = RD(), m = RD(), Seed = RD();
  for (register unsigned i(1); i <= n; ++i) {
    A = RD();
    if(!A) {
      Root = N + i;
      continue;
    }
    Link(N + A, N + i);
  }
  Root->Deep = 1;
  DFS1(Root), DFS2(Root);
  for (register unsigned i(1), L, R; i <= Hd; ++i) {
    register Node *x(Top[i]);
    L = x->DFSr, R = L + x->Len - 1;
    for (register unsigned j(L); j <= R; ++j) {
      List[j] = x - N;
      if(x->Fa[0]) x = x->Fa[0];
      else break;
    }
  }
  for (register unsigned i(1), j(0); i <= n; i <<= 1, ++j) {
    Log[i] = j, Bin[j] = i;
  }
  for (register unsigned i(3); i <= n; ++i) {
    Log[i] = max(Log[i], Log[i - 1]);
  }
  for (register unsigned i(1), Delta; i <= m; ++i) {
    A = ((Rand(Seed) ^ Ans) % n) + 1;
    B = (Rand(Seed) ^ Ans) % N[A].Deep;
    if(!B) {Ans = A, Prt ^= (unsigned long long)i * Ans; continue;}
    register Node *x(N[A].Fa[Log[B]]);
    B -= Bin[Log[B]];
    Delta = x->Top->Len - x->Len;
    if(Delta >= B) {
      Ans = InList[x->Top->DFSr + Delta - B];
    } else {
      Ans = List[x->Top->DFSr + B - Delta];
    }
    Prt ^= (unsigned long long)i * Ans;
  }
  printf("%llu\n", Prt);
  return Wild_Donkey;
}