BZOJ3669 膜法森林

Solution

非常妙的排序啊。。。

仔细想想好像确实能够找出最优解QUQ

先对第一关键字排序， 在$LCT$ 维护第二关键字的最大值 所在的边。

添边时如果$u, v$ 不连通 就直接加边。  如果连通 并且路径上的最大值 大于 当前边 的 第二关键字， 那么可以换掉。

如果 $1$ 和 $N$ 连通 就 更新答案。

 

这样就可以保证 在 所有路径上的边 第一关键字 小于等于 当前边 的第一关键字的前提下， 第二关键字的 最大值  最小。

除了这一点不一样， 其他就是模板了。

Code

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

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

int n, m;
int ans = inf;

struct edge {
    int u, v, a, b;
}e[N << 1];

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 cmp(const edge &A, const edge &B) {
    return A.a < B.a;
}

void cmin(int &A, int B) {
    if (A > B)
        A = B;
}

namespace LCT {
    int val[N << 1], f[N << 1], ch[N << 1][2], mx[N << 1], tun[N << 1];
#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) {
        mx[x] = val[x];
        if (e[mx[lc(x)]].b > e[mx[x]].b) mx[x] = mx[lc(x)];
        if (e[mx[rc(x)]].b > e[mx[x]].b) mx[x] = mx[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 << 1], 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[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);
    }

    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 main()
{
    n = rd; m = rd;
    for (int i = 1; i <= m; ++i) {
        e[i].u = rd; e[i].v = rd;
        e[i].a = rd; e[i].b = rd;
    }
    sort(e + 1, e + 1 + m, cmp);
    for (int i = 1; i <= m; ++i)
        val[i + n] = i;
    for (int i = 1; i <= m; ++i) {
        int x = e[i].u, y = e[i].v, t;
        if (x == y) continue;
        mroot(x);
        if (findr(y) != x)
            link(i + n, x), link(i + n, y);
        else if (e[t = mx[y]].b > e[i].b)
            cut(t + n, e[t].u), cut(t + n, e[t].v),
            link(i + n, x), link(i + n, y);
        mroot(1);
        if (findr(n) == 1)
            cmin(ans, e[i].a + e[mx[n]].b);
    }
    printf("%d
", ans == inf ? -1 : ans);
}