[BZOJ3669]魔法森林

题目链接：BZOJ3669

题目大意
有一个无向图，每一条边有两个权值$a$和$b$，求从$1$到$n$的一条路径使得这条路径的$max(a) + max(b)$最小。

分析
1. 假如每条边只有一个权值，那么就是一个最小生成树的题目，那么两个权值怎么处理呢?
2. 按照$kruskal$的做法，以$a$为第一关键字，$b$为第二关键字，将边集排序；对于第$i$条边，设其连接着$st$和$to$，$b$的值为$bi$。
2.1. 若$st$和$to$已联通，且对于$st$到$to$的路径，$max(b) > bi$，那么就可以删掉$b$最大的那条边，而替换成$i$这条边，这样的话图的联通性不变，同时更新最优解。
2.2 若$st$到$to$不联通，则连上这条边；若连边后$1$到$n$联通，则更新最优解。
3. 那么题目就变成了，当$max(a)$取某个值的时候，维护一个森林，使$max(b)$最小，用LCT维护，因为维护的是边权，于是要把每条边变成一个点。

上代码

#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;

int n, m;
inline int read() {
    char ch;
    int ans = 0, neg = 1;
    while (!isdigit(ch = getchar()))
        if (ch == '-') neg = -1;
    while (isdigit(ch))
        ans = ans * 10 + ch - '0', ch = getchar();
    return ans * neg;
}

namespace LCT {
    #define lc(a) (ch[a][0])
    #define rc(a) (ch[a][1])
    #define csk(a) (ch[fa[a]][1] == a)
    #define makeLink(a, b, c) fa[ch[a][c] = b] = a
    #define isRoot(a) (ch[fa[a]][0] != a && ch[fa[a]][1] != a)
    bool rev[N];
    int fa[N], ch[N][2], val[N], maxp[N];
    int cnt;
    inline void pushDown(int a) {
        if (rev[a]) {
            swap(lc(a), rc(a));
            rev[lc(a)] ^= 1, rev[rc(a)] ^= 1, rev[a] ^= 1;
        }
    }
    void pushDownTo(int a) {
        if (!isRoot(a))
            pushDownTo(fa[a]);
        pushDown(a);
    }
    inline void update(int a) {
        maxp[a] = a;
        if (lc(a) && val[maxp[lc(a)]] > val[maxp[a]])
            maxp[a] = maxp[lc(a)];
        if (rc(a) && val[maxp[rc(a)]] > val[maxp[a]])
            maxp[a] = maxp[rc(a)];
    }
    inline void rotate(int a) {
        int k = csk(a), f = fa[a];
        makeLink(f, ch[a][k ^ 1], k);
        if (isRoot(f)) fa[a] = fa[f];
        else makeLink(fa[f], a, csk(f));
        makeLink(a, f, k ^ 1);
        update(f), update(a);
    }
    void splay(int a) {
        pushDownTo(a);
        while (!isRoot(a)) {
            if (!isRoot(fa[a])) {
                if (csk(a) == csk(fa[a])) rotate(fa[a]);
                else rotate(a);
            } rotate(a);
        }
    }
    void access(int a) {
        splay(a), rc(a) = 0, update(a);
        for (int i = fa[a]; i; i = fa[a = i])
            splay(i), makeLink(i, a, 1), update(i);
    }
    inline void makeRoot(int a) {
        access(a), splay(a), rev[a] ^= 1, pushDown(a);
    }
    inline void link(int a, int b) {
        makeRoot(a), fa[a] = b;
    }
    inline void cut(int a, int b) {
        makeRoot(a), access(b), splay(b);
        lc(b) = fa[a] = 0, update(b);
    }
    inline int getMax(int a, int b) {
        return makeRoot(a), access(b), splay(b), val[maxp[b]];
    }
    inline void delMax(int a, int b) {
        makeRoot(a), access(b), splay(b);
        int tmp = maxp[b];
        cut(a, tmp), cut(b, tmp);
    }
    inline void addLink(int a, int b, int c) {
        int tmp = ++cnt; val[tmp] = c;
        update(tmp), link(a, tmp), link(b, tmp);
    }
}

int fa[N];
struct Edge {
    int st, to, x, y;
    Edge() {}
    Edge(int a, int b, int c, int d) : st(a), to(b), x(c), y(d) {}
    inline bool operator < (const Edge &a) const {
        return x != a.x ? x < a.x : y < a.y;
    }
}; vector <Edge> E;
void init() {
    LCT::cnt = n = read(), m = read();
    for (int i = 1; i <= n; i++) fa[i] = i;
    for (int i = 1; i <= m; i++) {
        int a = read(), b = read(), c = read(), d = read();
        if (a != b) E.push_back(Edge(a, b, c, d));
    } sort(E.begin(), E.end());
}
int findRoot(int a) {
    return fa[a] == a ? a : fa[a] = findRoot(fa[a]);
}
int figure() {
    int ans = INF;
    for (int i = 0; i < E.size(); i++) {
        int a = E[i].st, b = E[i].to;
        if (findRoot(a) == findRoot(b)) {
            if (LCT::getMax(a, b) >= E[i].y)
                LCT::delMax(a, b), LCT::addLink(a, b, E[i].y);
        } else LCT::addLink(a, b, E[i].y), fa[findRoot(a)] = findRoot(b);
        if (findRoot(1) == findRoot(n))
            ans = min(ans, E[i].x + LCT::getMax(1, n));
    }
    return ans == INF ? -1 : ans;
}

int main() {
    init();
    printf("%d\n", figure());
    return 0;
}

以上