BZOJ 2594 水管局长

Solution

由于链信息不好直接维护， 所以新建一个节点存储边的权值， 并把这个节点连向 它所连的节点 $u$, $v$

$pushup$中更新维护的 $mx$ 指向路径上权值最大的边的编号。

由于这题是只有删边， 没有添边， 所以可以离线倒序， 把删边变成添边。

Code

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

const int N = 1e6 + 5;

int n, m, Q, ans[N];

struct edge {
    int u, v, id, val, d;
}e[N];

struct que {
    int typ, u, v, id;
}q[N];

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;
}

namespace LCT {
    int ch[N][2], f[N], mx[N], tun[N], val[N];
    int st[N], tp;
#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 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) {
        while (!isroot(x)) {
            st[++tp] = x;
            x = f[x];
        }
        st[++tp] = x;
        while (tp) pushdown(st[tp--]);
    }

    void up(int x) {
        mx[x] = val[x];
        if (e[mx[lc(x)]].val > e[mx[x]].val) mx[x] = mx[lc(x)];
        if (e[mx[rc(x)]].val > e[mx[x]].val) mx[x] = mx[rc(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[x] = oldf; f[old] = x; f[son] = old;
        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);
    }

    void split(int x, int y) {
        mroot(x); 
        access(y); 
        splay(y);
    }

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

    void link(int x, int y) {
        mroot(x); f[x] = y;
    }

    void cut(int x, int y) {
        split(x, y);
        f[x] = ch[y][0] = 0;
    }
}
using namespace LCT;

int fd(int x, int y) {
    int l = 1, r = m;
    for (; l <= r;) {
        int mid = (l + r) >> 1;
        if (e[mid].u < x || (e[mid].u == x && e[mid].v < y))
            l = mid + 1;
        else if (e[mid].u == x && e[mid].v == y) return mid;
        else r = mid - 1;
    }
    return 0;
}

int cmp1(const edge &A, const edge &B) {
    return A.val < B.val;
}

int cmp2(const edge &A, const edge &B) {
    return A.u == B.u ? A.v < B.v : A.u < B.u;
}

int cmp3(const edge &A, const edge &B) {
    return A.id < B.id;
}

int main()
{
    n = rd; m = rd; Q = rd;
    for (int i = 1; i <= m; ++i) {
        e[i].u = rd, e[i].v = rd, e[i].val = rd;
        if (e[i].u > e[i].v)
            swap(e[i].u, e[i].v);
    }
    sort(e + 1, e + 1 + m, cmp1);
    for (int i = 1; i <= m; ++i) 
        e[i].id = i, val[i + n] = i;
    sort(e + 1, e + 1 + m, cmp2);
    for (int i = 1; i <= Q; ++i) {
        q[i].typ = rd;
        q[i].u = rd;
        q[i].v = rd;
        if (q[i].u > q[i].v) 
            swap(q[i].u, q[i].v);
        if (q[i].typ == 2) {
            int t = fd(q[i].u, q[i].v);
            q[i].id = e[t].id;
            e[t].d = 1;
        }
    }
    sort(e + 1, e + 1 + m, cmp3);
    for (int i = 1, tot = 0; i <= m; ++i) if (!e[i].d) {
        int x = e[i].u, y = e[i].v;
        mroot(x);
        if (findr(y) != x) {
            link(x, i + n);
            link(y, i + n);
            tot++;
        }
        if (tot == n - 1) break;
    }
    for (int i = Q; i; i--) {
        if (q[i].typ == 1) {
            split(q[i].u, q[i].v);
            ans[i] = e[mx[q[i].v]].val;
        }
        else {
            int x = q[i].u, y = q[i].v;
            mroot(x);
            if (findr(y) != x) {
                link(y, q[i].id + n);
                link(x, q[i].id + n);
                continue;
            }
            if (e[mx[y]].val > e[q[i].id].val) {
                int t = mx[y];
                cut(t + n, e[t].u);
                cut(t + n, e[t].v);
                link(q[i].id + n, x);
                link(q[i].id + n, y);
            }
        }
    }
    for (int i = 1; i <= Q; ++i)
        if (q[i].typ == 1)
            printf("%d
", ans[i]);
}