【BZOJ2959】长跑（LCT，双连通分量，并查集）

Description

　　某校开展了同学们喜闻乐见的阳光长跑活动。为了能“为祖国健康工作五十年”，同学们纷纷离开寝室，离开教室，离开实验室，到操场参加3000米长跑运动。一时间操场上熙熙攘攘，摩肩接踵，盛况空前。
　　为了让同学们更好地监督自己，学校推行了刷卡机制。
　　学校中有n个地点，用1到n的整数表示，每个地点设有若干个刷卡机。
　　有以下三类事件：
　　1、修建了一条连接A地点和B地点的跑道。
　　2、A点的刷卡机台数变为了B。
　　3、进行了一次长跑。问一个同学从A出发，最后到达B最多可以刷卡多少次。具体的要求如下：
　　当同学到达一个地点时，他可以在这里的每一台刷卡机上都刷卡。但每台刷卡机只能刷卡一次，即使多次到达同一地点也不能多次刷卡。
　　为了安全起见，每条跑道都需要设定一个方向，这条跑道只能按照这个方向单向通行。最多的刷卡次数即为在任意设定跑道方向，按照任意路径从A地点到B地点能刷卡的最多次数。

---

Solution

考虑用LCT维护，如果出现了环，那么我们用并查集将它们缩起来即可。

---

Code

/************************************************
 * Au: Hany01
 * Date: Aug 10th, 2018
 * Prob: BZOJ2959 长跑
 * Email: hany01@foxmail.com
 * Inst: Yali High School
************************************************/

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
#define rep(i, j) for (register int i = 0, i##_end_ = (j); i < i##_end_; ++ i)
#define For(i, j, k) for (register int i = (j), i##_end_ = (k); i <= i##_end_; ++ i)
#define Fordown(i, j, k) for (register int i = (j), i##_end_ = (k); i >= i##_end_; -- i)
#define Set(a, b) memset(a, b, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define x first
#define y second
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define SZ(a) ((int)(a).size())
#define INF (0x3f3f3f3f)
#define INF1 (2139062143)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define y1 wozenmezhemecaia

template <typename T> inline bool chkmax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template <typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }

inline int read() {
    static int _, __; static char c_;
    for (_ = 0, __ = 1, c_ = getchar(); c_ < '0' || c_ > '9'; c_ = getchar()) if (c_ == '-') __ = -1;
    for ( ; c_ >= '0' && c_ <= '9'; c_ = getchar()) _ = (_ << 1) + (_ << 3) + (c_ ^ 48);
    return _ * __;
}

const int maxn = 150005;

int n, pa[maxn], val[maxn];

struct LCT {

    int val[maxn], rev[maxn], ch[maxn][2], fa[maxn], pa[maxn], sum[maxn];

#define dir(t) (ch[find(fa[t])][1] == t)
#define isrt(t) (ch[find(fa[t])][0] != t && ch[find(fa[t])][1] != t)

    inline int find(int t) { return pa[t] == t ? t : pa[t] = find(pa[t]); }

    inline void reverse(int t) { swap(ch[t][0], ch[t][1]), rev[t] ^= 1; }

    inline void pushdown(int t) {
        if (rev[t]) {
            rev[t] = 0;
            if (ch[t][0]) reverse(ch[t][0]);
            if (ch[t][1]) reverse(ch[t][1]);
        }
    }

    inline void maintain(int t) { sum[t] = sum[ch[t][0]] + sum[ch[t][1]] + val[t]; }

    inline void rotate(int u) {
        static int f, gf, d; f = find(fa[u]), gf = find(fa[f]), d = dir(u);
        if (!isrt(f)) ch[gf][dir(f)] = u;
        fa[u] = gf;
        fa[ch[f][d] = ch[u][d ^ 1]] = f;
        fa[ch[u][d ^ 1] = f] = u;
        maintain(f), maintain(u);
    }

    inline void splay(int u) {
        static int stk[maxn], top;
        stk[top = 1] = u;
        for (register int t = u; !isrt(t); t = find(fa[t])) stk[++ top] = find(fa[t]);
        while (top) pushdown(stk[top --]);
        for (register int t = find(fa[u]); !isrt(u); rotate(u), t = find(fa[u]))
            if (!isrt(t)) rotate(dir(u) == dir(t) ? t : u);
        maintain(u);
    }

    inline void access(int u) {
        for (register int t = 0; u; u = find(fa[t = u])) splay(u), ch[u][1] = t, maintain(u);
    }

    inline void makert(int u) { access(u), splay(u), reverse(u); }

    inline void split(int u, int v) { makert(u), access(v), splay(v); }

    inline void link(int u, int v) { makert(u), fa[u] = v; }

    void shrink(int u, int rt) {
        if (ch[u][0]) shrink(ch[u][0], rt);
        if (ch[u][1]) shrink(ch[u][1], rt);
        pa[u] = rt, val[rt] += val[u];
    }

    inline void addval(int u, int dt) {
        u = find(u), access(u), splay(u), val[u] += dt, maintain(u);
    }

}lct;


int find(int x) { return x == pa[x] ? x : pa[x] = find(pa[x]); }

inline void addedge(int u, int v) {
    u = lct.find(u), v = lct.find(v);
    if (u == v) return;
    static int fu, fv; fu = find(u), fv = find(v);
    if (fu != fv) pa[fu] = fv, lct.link(u, v);
    else lct.split(u, v), lct.shrink(lct.ch[v][0], v);
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("graph.in", "r", stdin);
    freopen("graph.out", "w", stdout);
#endif

    static int m, op, x, y;

    n = read(), m = read();
    For(i, 1, n) lct.val[i] = val[i] = read(), pa[i] = lct.pa[i] = i;

    while (m --) {
        op = read(), x = read(), y = read();
        if (op == 1) addedge(x, y);
        else if (op == 2) lct.addval(x, y - val[x]), val[x] = y;
        else {
            if (find(x) != find(y)) puts("-1");
            else {
                x = lct.find(x), y = lct.find(y);
                lct.split(x, y), printf("%d\n", lct.sum[y]);
            }
        }
    }

    return 0;
}