【NOI2014】魔法森林

Description

给定一张无向图，边有a，b两种边权，求一条1~n的路径，使得路径上a最大值与b最大值之和尽可能小

Solution

LCT维护生成树

将边按照a从小到大排序，然后顺序考虑每一条边

如果当前这条边的两个端点没有联通，那么直接在LCT上连边即可

如果当前这条边的两个端点已经连通，那么在LCT上找到这两点之间b值最大的一条边，若这条边的b值大于当前这条边那么将那条边断掉换成当前边

在任意时刻，若1与n联通，那么直接更新答案

Code

#include <bits/stdc++.h>
using namespace std;
inline int read() {
    int ret = 0, op = 1;
    char c = getchar();
    while (!isdigit(c)) {
        if (c == '-') op = -1; 
        c = getchar();
    }
    while (isdigit(c)) {
        ret = (ret << 3) + (ret << 1) + c - '0';
        c = getchar();
    }
    return ret * op;
}
const int N = 200010;
const int S = 131072;
int n, m, s[N];
struct Edge {
    int from, to, da, db;
    bool operator <(const Edge &x) const {
        return da < x.da;
    }
} e[N];
struct LCT {
    int fa, val, ch[2], maxx, tag;
} a[N];
inline int isnroot(int now) {
    return a[a[now].fa].ch[0] == now || a[a[now].fa].ch[1] == now;
}
inline void update(int now) {
    int l = a[now].ch[0];
    int r = a[now].ch[1];
    a[now].maxx = now;
    if (e[a[l].maxx].db > e[a[now].maxx].db) a[now].maxx = a[l].maxx;
    if (e[a[r].maxx].db > e[a[now].maxx].db) a[now].maxx = a[r].maxx;
}
inline void rev(int now) {
    swap(a[now].ch[0], a[now].ch[1]);
    a[now].tag ^= 1;
}
inline void pushdown(int now) {
    if (a[now].tag) {
        if (a[now].ch[0]) rev(a[now].ch[0]);
        if (a[now].ch[1]) rev(a[now].ch[1]);
        a[now].tag = 0;
    }
}
void rotate(int x) {
    int y = a[x].fa;
    int z = a[y].fa;
    int xson = a[y].ch[1] == x;
    int yson = a[z].ch[1] == y;
    int B = a[x].ch[xson ^ 1];
    if (isnroot(y)) a[z].ch[yson] = x;
    a[x].ch[xson ^ 1] = y;
    a[y].ch[xson] = B;
    if (B) a[B].fa = y;
    a[y].fa = x;
    a[x].fa = z;
    update(y);
}
void splay(int x) {
    int y = x, z = 0;
    s[++z] = y;
    while (isnroot(y)) y = a[y].fa, s[++z] = y;
    while (z) pushdown(s[z--]);
    while (isnroot(x)) {
        y = a[x].fa;
        z = a[y].fa;
        if (isnroot(y))
            (a[z].ch[0] == y) ^ (a[y].ch[0] == x) ? rotate(x) : rotate(y);
        rotate(x);
    }
    update(x);
}
void access(int x) {
    for (register int y = 0; x; y = x, x = a[x].fa) {
        splay(x); a[x].ch[1] = y; update(x);
    }
}
void makeroot(int x) {
    access(x);
    splay(x);
    rev(x);
}
int findroot(int x) {
    access(x); splay(x);
    while (a[x].ch[0]) pushdown(x), x = a[x].ch[0];
    return x;
}
void link(int i) {
    makeroot(e[i].to);
    a[e[i].to].fa = i;
    a[i].fa = e[i].from;
}
void cut(int i) {
    access(i); splay(i);
    a[a[i].ch[0]].fa = a[a[i].ch[1]].fa = 0;
    a[i].ch[0] = a[i].ch[1] = 0;
    update(i);
}
int main() {
    n = read(); m = read();
    for (register int i = 1; i <= m; ++i) {
        e[i].from = read() | S; e[i].to = read() | S; e[i].da = read(); e[i].db = read();
    }
    sort(e + 1, e + m + 1);
    int ans = 2147483647;
    for (register int i = 1; i <= m; ++i) {
        int x = e[i].from, y = e[i].to;
        if (x == y) continue ;
        makeroot(x);
        if (x != findroot(y)) link(i);
        else if (e[i].db < e[a[y].maxx].db) cut(a[y].maxx), link(i);
        makeroot(1 | S);
        if ((1 | S) == findroot(n | S)) ans = min(ans, e[i].da + e[a[n | S].maxx].db);
    }
    printf("%d
", ans == 2147483647 ? -1 : ans);
    return 0;
}