「HNOI2010」弹飞绵羊

题面

题目描述

某天，Lostmonkey 发明了一种超级弹力装置，为了在他的绵羊朋友面前显摆，他邀请小绵羊一起玩个游戏。

游戏一开始，Lostmonkey 在地上沿着一条直线摆上 $n$ 个装置，每个装置设定初始弹力系数 $k_i$，当绵羊达到第 $i$ 个装置时，它会往后弹 $k_i$ 步，达到第 $i + k_i$ 个装置，若不存在第 $i + k_i$ 个装置，则绵羊被弹飞。

绵羊想知道当它从第 $i$ 个装置起步时，被弹几次后会被弹飞。为了使得游戏更有趣，Lostmonkey 可以修改某个弹力装置的弹力系数，任何时候弹力系数均为正整数。

输入格式

第一行包含一个整数 $n$，表示地上有 $n$ 个装置，装置的编号从 $0 \sim n - 1$。

接下来一行有 $n$ 个正整数，依次为那 $n$ 个装置的初始弹力系数。

第三行有一个正整数 $m$，表示操作次数。接下来 $m$ 行每行至少有两个数 $i,j$。

• 若 $i = 1$，你要输出从 $j$ 出发被弹几次后被弹飞；
• 若 $i = 2$，则还会再输入一个正整数 $k$，表示第 $j$ 个弹力装置的系数被修改成 $k$。

输出格式

对于每个 $i = 1$ 的操作，输出一行一个整数表示答案。

输入输出样例

样例输入 #1

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

样例输出 #1

2
3

数据范围与约定

对于 $20\%$ 的数据，$1 \le n, m \le 10^4$；
对于 $100\%$ 的数据，$1 \le n \le 2 \times 10^5$，$1 \le m \le 10^5$。

思路

首先将题中给的所有编号 $+ 1$ 方便计算。

设节点 $n + 1$ 为终点，从所有可以弹飞的点连一条边到这个点上，就可以用 LCT 来求出路径上的节点数了。也有作为森林维护的方法，此处不再做过多说明。

代码

#include <iostream>
#include <stack>

using std::cin;
using std::cout;
const char endl = '\n';

const int N = 2e5 + 5;

int n, m, a[N];

class LinkCutTree {
  private:
    struct node {
        size_t l, r, f;
        unsigned s;
        bool rev;

        node()
            : l(0), r(0), f(0), s(0), rev(false) {}

        node(size_t _f)
            : l(0), r(0), f(_f), s(1), rev(false) {}

        size_t &child(unsigned x) {
            return !x ? l : r;
        }
    } tr[N];

    inline void pushup(size_t u) {
        tr[u].s = tr[tr[u].l].s + 1 + tr[tr[u].r].s;
    }

    inline void pushdown(const size_t &u) {
        if (!tr[u].rev) return;

        std::swap(tr[u].l, tr[u].r);
        tr[tr[u].l].rev = !tr[tr[u].l].rev;
        tr[tr[u].r].rev = !tr[tr[u].r].rev;
        tr[u].rev = false;
    }

    unsigned relation(const size_t &u) {
        return u == tr[tr[u].f].l ? 0 : 1;
    }

    bool isRoot(const size_t &u) {
        return tr[tr[u].f].l != u && tr[tr[u].f].r != u;
    }

    void rotate(size_t u) {
        size_t p = tr[u].f;
        unsigned x = relation(u);

        if (!isRoot(p)) {
            tr[tr[p].f].child(relation(p)) = u;
        }
        tr[u].f = tr[p].f;

        if (tr[u].child(x ^ 1)) {
            tr[tr[u].child(x ^ 1)].f = p;
        }
        tr[p].child(x) = tr[u].child(x ^ 1);

        tr[u].child(x ^ 1) = p;
        tr[p].f = u;

        pushup(p);
        pushup(u);
    }

    void splay(size_t u) {
        std::stack<size_t> st;

        size_t cur = u;
        st.push(cur);
        while (!isRoot(cur)) {
            st.push(tr[cur].f);
            cur = tr[cur].f;
        }

        while (!st.empty()) {
            pushdown(st.top());
            st.pop();
        }

        while (!isRoot(u)) {
            if (isRoot(tr[u].f)) {
                rotate(u);
            } else if (relation(u) == relation(tr[u].f)) {
                rotate(tr[u].f);
                rotate(u);
            } else {
                rotate(u);
                rotate(u);
            }
        }
    }

    void access(size_t u) {
        for (size_t f = 0; u; u = tr[f = u].f) {
            splay(u);
            tr[u].r = f;
            pushup(u);
        }
    }

    void makeRoot(const size_t &u) {
        access(u);
        splay(u);
        tr[u].rev = !tr[u].rev;
    }

    size_t findRoot(size_t u) {
        access(u);
        splay(u);

        while (tr[u].l) {
            u = tr[u].l;
        }

        return u;
    }

    void split(const size_t &x, const size_t &y) {
        makeRoot(x);
        access(y);
        splay(y);
    }

  public:
    unsigned query(int x, int y) {
        split(x, y);

        return tr[y].s;
    }

    void link(const int &x, const int &y) {
        makeRoot(x);

        if (findRoot(y) != x) {
            tr[x].f = y;
        }
    }

    void cut(int x, int y) {
        split(x, y);

        if (tr[y].l == x) {
            tr[y].l = 0;
            tr[x].f = 0;
        }
    }
} lct;

int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;

    for (int i = 1; i <= n; i++) {
        cin >> a[i];

        lct.link(i, std::min(i + a[i], n + 1));
    }

    cin >> m;

    while (m--) {
        int op, x, y;

        cin >> op;

        if (op == 1) {
            cin >> x;

            cout << lct.query(x + 1, n + 1) - 1 << endl;
        } else {  // op == 2
            cin >> x >> y;

            x++;
            lct.cut(x, std::min(x + a[x], n + 1));
            lct.link(x, std::min(x + (a[x] = y), n + 1));
        }
    }

    return 0;
}