UOJ 274 温暖会指引我们前进

Solution

更新掉路径上温暖度最小的边就可以了~

Code

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

const int N = 4e5 + 5;
const int inf = ~0U >> 1;

int n, m, fa[N];

struct edge {
    int u, v, t, w;
}e[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;
}

int anc(int x) {
    return fa[x] == x ? x : fa[x] = anc(fa[x]);
}

namespace LCT {
    int f[N], ch[N][2], val[N], mn[N], tun[N];
    ll sum[N];
#define lc(x) ch[x][0]
#define rc(x) ch[x][1]

    int isroot(int x) {
        return lc(f[x]) != x && rc(f[x]) != x;
    }

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

    void up(int x) {
        mn[x] = val[x];
        sum[x] = e[val[x]].t;
        if (e[mn[lc(x)]].w < e[mn[x]].w) mn[x] = mn[lc(x)];
        if (e[mn[rc(x)]].w < e[mn[x]].w) mn[x] = mn[rc(x)];
        if (lc(x)) sum[x] += sum[lc(x)];
        if (rc(x)) sum[x] += sum[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;
        }
    }

int st[N], tp;

    void pd(int x) {
        while (!isroot(x)) {
            st[++tp] = x;
            x = f[x];
        }
        pushdown(x);
        while (tp) pushdown(st[tp--]);
    }

    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[x] = oldf; 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);
    }

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

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

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

    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 main()
{
    e[0].w = inf;
    n = rd; m = rd;
    for (int i = 1; i <= n; ++i)
        fa[i] = i;
    for (int i = 1; i <= m; ++i)
        val[i + n] = i;
    char op[10];
    for (int i = 1; i <= m; ++i) {
        scanf("%s", op);
        if (op[0] == 'f') {
            int id = rd + 1;
            e[id].u = rd + 1;
            e[id].v = rd + 1;
            e[id].w = rd;
            e[id].t = rd;
            int x = e[id].u, y = e[id].v;
            if (anc(x) != anc(y)) {
                link(id + n, x);
                link(id + n, y);
                x = anc(x); y = anc(y);
                fa[x] = y;
            }
            else {
                split(x, y);
                int t = mn[y];
                if (e[id].w < e[t].w) 
                    continue;
                cut(t + n, e[t].u);
                cut(t + n, e[t].v);
                link(id + n, e[id].u);
                link(id + n, e[id].v);
            }
        }
        else if(op[0] == 'm') {
            int x = rd + 1, y = rd + 1;
            if (anc(x) != anc(y)) {
                puts("-1"); continue;
            }
            if (x == y) {puts("0"); continue;}
            split(x, y);
            printf("%lld
", sum[y]);
        }
        else {
            int id = rd + 1;
            e[id].t = rd;
            mroot(id + n);
        }
    }
}