Luogu 2173 [ZJOI2012]网络

Solution

$LCT$ 直接上$QuQ$

注意$cut$ 完 需要 $d[u + c * N]--$ 再  $link$,  不然会输出Error 1的哦

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#define rd read()
using namespace std;

const int N = 1e5 + 5;

int n, m, col, Q;

int read() {
    int X = 0, p = 1; char c = getchar();
    for (; c > '9' || c < '0'; c = getchar())
        if (c == '-' ) p = -1;
    for (; c >= '0' && c <= '9'; c = getchar())
        X = X * 10 + c - '0';
    return X * p;
}

void cmax(int &a, int b) {
    if (a < b)
        a = b;
}

namespace LCT {
    int val[N], Max[N], f[N], ch[N][2], tun[N], d[N];
#define lc(x) ch[x][0]
#define rc(x) ch[x][1]
    int isroot(int x) {
        return rc(f[x]) != x && lc(f[x]) != x;
    }

    int get(int x) {
        return rc(f[x]) == x;
    }

    void up(int x) {
        Max[x] = val[x];
        if (lc(x)) cmax(Max[x], Max[lc(x)]);
        if (rc(x)) cmax(Max[x], Max[rc(x)]);
    }

    void rev(int x) {
        swap(lc(x), rc(x));
        tun[x] ^= 1;
    }

    void pushdown(int x) {
        if (tun[x]) {
            if (lc(x)) rev(lc(x));
            if (rc(x)) rev(rc(x));
            tun[x] = 0;
        }
    }

    void pd(int x) {
        if (!isroot(x))
            pd(f[x]);
        pushdown(x);
    }

    void rotate(int x) {
        int old = f[x], oldf = f[old], son = ch[x][get(x) ^ 1];
        if (!isroot(old)) ch[oldf][get(old)] = x;
        ch[x][get(x) ^ 1] = old;
        ch[old][get(x)] = son;
        f[old] = x; f[son] = old; f[x] = oldf;
        up(old); up(x);
    }

    void splay(int x) {
        pd(x);
        for (; !isroot(x); rotate(x))
            if (!isroot(f[x]))
                rotate(get(f[x]) == get(x) ? f[x] : x);
    }

    void access(int x) {
        for (int y = 0; x; y = x, x = f[x])
            splay(x), ch[x][1] = y, up(x);
    }

    void mroot(int x) {
        access(x); splay(x); rev(x);
    }

    int findr(int x) {
        access(x); splay(x);
        while (lc(x)) pushdown(x), x = lc(x);
        return x;
    }

    void split(int x, int y) {
        mroot(x); access(y); splay(y);
    }
    
    int link(int x, int y) {
        if (d[x] > 1 || d[y] > 1)
            return 1;
        mroot(x);
        if (findr(y) == x)
            return 2;
        f[x] = y;
        return 3;
    }

    int cut(int x, int y) {
        mroot(x);
        if (findr(y) != x || f[x] != y || ch[x][1])
            return 0;
        f[x] = ch[y][0] = 0;
        return 1;
    }
}
using namespace LCT;

int main()
{
    n = rd; m = rd; col = rd; Q = rd;
    for (int i = 1; i <= n; ++i) {
        int tmp = rd;
        for (int j = 0; j < col; ++j)
            val[i + j * n] = tmp;
    }
    for (int i = 1; i <= m; ++i) {
        int u = rd, v = rd, z = rd;
        link(u + z * n, v + z * n);
        d[u + z * n]++;
        d[v + z * n]++;
    }
    for (; Q; Q--) {
        int k = rd;
        if (k == 0) {
            int u = rd, v = rd;
            for (int j = 0; j < col; ++j) 
                mroot(u + j * n), val[u + j * n] = v, up(u + j * n);
        }
        if (k == 1) {
            int u = rd, v = rd, z = rd, flag = 0, c;
            for (int j = 0; j < col && !flag; ++j) {
                flag = cut(u + j * n, v + j * n);
                if (flag) c = j;
            }
            if (!flag) {puts("No such edge."); continue;}
            d[u + c * n]--; d[v + c * n]--;
            flag = link(u + z * n, v + z * n);
            if (flag == 1) {
                puts("Error 1.");
                link(u + c * n, v + c * n);
                d[u + c * n]++; d[v + c * n]++;
            }
            else if (flag == 2) {
                puts("Error 2.");
                link(u + c * n, v + c * n);
                d[u + c * n]++; d[v + c * n]++;
            }
            else {
                puts("Success.");
                d[u + z * n]++; d[v + z * n]++;
            }
        }
        if (k == 2) {
            int z = rd, u = rd, v = rd;
            u = u + z * n;
            v = v + z * n;
            mroot(u);
            if (findr(v) != u) {puts("-1"); continue;}
            printf("%d
", max(Max[lc(v)], val[v]));
        }
    }
}