BZOJ 2002: [Hnoi2010]Bounce 弹飞绵羊(LCT)

Description

某天，Lostmonkey发明了一种超级弹力装置，为了在他的绵羊朋友面前显摆，他邀请小绵羊一起玩个游戏。游戏一开始，Lostmonkey在地上沿着一条直线摆上n个装置，每个装置设定初始弹力系数ki，当绵羊达到第i个装置时，它会往后弹ki步，达到第i+ki个装置，若不存在第i+ki个装置，则绵羊被弹飞。绵羊想知道当它从第i个装置起步时，被弹几次后会被弹飞。为了使得游戏更有趣，Lostmonkey可以修改某个弹力装置的弹力系数，任何时候弹力系数均为正整数。

---

Input

第一行包含一个整数n，表示地上有n个装置，装置的编号从0到n-1,接下来一行有n个正整数，依次为那n个装置的初始弹力系数。第三行有一个正整数m，接下来m行每行至少有两个数i、j，若i=1，你要输出从j出发被弹几次后被弹飞，若i=2则还会再输入一个正整数k，表示第j个弹力装置的系数被修改成k。对于20%的数据n,m<=10000，对于100%的数据n<=200000,m<=100000

---

Output

对于每个i=1的情况，你都要输出一个需要的步数，占一行。

---

Sample Input

4
1 2 1 1
3
1 1
2 1 1
1 1

---

Sample Output

2
3

---

Solution

本题是一道LCT的入门题。其实还有分块的作法。

最近在写LCT，就按照LCT的思路去分析这道题。
首先，很容易看出将每个装置向其能弹跳到的装置连边后，会构成一片无根森林。然后每个装置(看作点)，只能通过其所在的那棵树被弹飞。这样，每次修改一个装置的弹力系数，相当于在改变这个森林的形态。于是用动态树来做无疑。

每个点连边，如果连出去了怎么办呢？不能不管，所以我们构建一个编号为n的虚拟节点代表到此就已经被弹飞了。然后如果从一个装置能直接被弹飞后就直接连向虚拟节点。这样森林就通过此节点连成了一棵树，然后问题就转化为：动态维护一棵树，每次询问一个点离点n的距离。

我们看出如果讲点n作为树的根的话，问题就是求一个点的深度减1(根的深度为1的话)。我们将点n$Evert()$使之为根，然后将当前询问的点i$Access()$然后这两个点到了一条树链上，直接查询维护这条树链的splay树的size，答案就是size-1。修改就是简单的$Cut()$和$Link()$。

如果我们不构建虚拟节点的话，每次查链的深度(即splay树的size)时，就不知道链顶端的根是什么，又没有被弹飞，所以构建虚拟结点必要的。类似的构造虚拟节点的还有最短路径中的超级源点，网络流中的超级源点和超级汇点等等，splay中的哨兵也算得上是吧。。总之，这类技巧在图论与数据结构中较常见。

---

Code

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <cstring>
#define N 200010

using namespace std;

int n, m, cnt;
int k[N];
struct Tnode{
    Tnode *son[2], *fa;
    int Size, parent, id;
    bool rev;
    int Lsize(){return son[0] ? son[0]->Size : 0;}
    int Rsize(){return son[1] ? son[1]->Size : 0;}
    int Get_d(){return fa->son[1] == this;}
    void Connect(Tnode *now, int d){(son[d] = now)->fa = this;}
    void Up(){Size = Lsize() + Rsize() + 1;}
    void Down(){
      if(rev){
        swap(son[0], son[1]);
        if(son[0])  son[0]->rev ^= 1;
        if(son[1])  son[1]->rev ^= 1;
        rev = false;
      }
    }
}tree[N], *Node[N];

Tnode *NewTnode(int id){
    tree[cnt].son[0] = tree[cnt].son[1] = NULL;
    tree[cnt].fa = NULL;
    tree[cnt].parent = 0;
    tree[cnt].id = id;
    tree[cnt].Size = 1;
    tree[cnt].rev = false;
    return tree+cnt++;
}

void Zig(Tnode *now){
    Tnode *last = now->fa;
    int d = now->Get_d();
    if(now->son[!d])  last->Connect(now->son[!d], d);
    else  last->son[d] = NULL;
    if(last->fa)  last->fa->Connect(now, last->Get_d());
    else  now->fa = NULL;
    now->Connect(last, !d);
    last->Up();
    now->parent = last->parent;
    last->parent = 0;
}

void Splay(Tnode *now){
    Tnode *last;
    while(now->fa){
      last = now->fa;
      if(last->fa)  last->fa->Down();
      last->Down();  now->Down();
      if(last->fa)  (now->Get_d() ^ last->Get_d()) ? Zig(now) : Zig(last);
      Zig(now);
    }
    if(!now->fa)  now->Down();
    now->Up();
}

void Access(int x){
    Splay(Node[x]);
    if(Node[x]->son[1]){
      Node[x]->son[1]->fa = NULL;
      Node[x]->son[1]->parent = x;
      Node[x]->son[1] = NULL;
      Node[x]->Up();
    }

    int y = Node[x]->parent;
    while(y){
      Splay(Node[y]);
      if(Node[y]->son[1]){
        Node[y]->son[1]->fa = NULL;
        Node[y]->son[1]->parent = y;
        Node[y]->son[1] = NULL;
        Node[y]->Up();
      }
      Node[y]->Connect(Node[x], 1);
      Node[y]->Up();
      Node[x]->parent = 0;
      x = y;
      y = Node[x]->parent;
    }
}

void Evert(int x){
    Access(x);
    Splay(Node[x]);
    Node[x]->rev ^= 1;
}

void Link(int x, int y){
    Evert(x);
    Node[x]->parent = y;
}

void Cut(int x, int y){
    Evert(x);
    Access(y);
    Splay(Node[x]);
    Node[x]->son[1]->fa = NULL;
    Node[x]->son[1] = NULL;
    Node[x]->Up(); 
}

int main(){

    freopen("bzoj2002.in", "r", stdin);
    freopen("bzoj2002.out", "w", stdout);

    scanf("%d", &n);
    for(int i = 0; i <= n; i++)  Node[i] = NewTnode(i);

    for(int i = 0; i < n; i++){
      scanf("%d", &k[i]);
      Link(i, min(i+k[i], n));
    }

    scanf("%d", &m);

    int a, b, c;
    for(int i = 1; i <= m; i++){
      scanf("%d%d", &a, &b);
      if(a == 1){
        Evert(n);
        Access(b);
        Splay(Node[b]);
        printf("%d\n", Node[b]->Size-1);
      }
      else{
        scanf("%d", &c);
        Cut(b, min(b+k[b], n));
        Link(b, min(b+c, n));
        k[b] = c;
      }
    }
    return 0;
}

---

Brave shine.