LOJ#2245 魔法森林

这道题以前zbtrs大佬给我讲过。但是我只知道思想，不知道要lct维护...

这个套路很常见。

题意：给你一个无向图，每条边有a，b两个权值。求1到n号点的一条路径，路径的权值是每条边的最大a与最大b之和。求可能的最小权值。无解输出-1。

解：有个很朴素的想法是爆搜......

有个很朴素(??)的想法，最后路径的a最大值一定是某条边的a，于是我们枚举这个a，每次把小于a的边都加进去，然后若1，n连通就跑b的最短路。这样就有50分了。

然后我们发现每次跑最短路的时间不可承受，如何优化呢？

我们肯定会在某一时刻加出环，然后我们发现这个环上的a的大小是无关紧要的，我们把环上b最大的边去掉，这样就是一棵树了。

然后用lct实行这个操作，时间复杂度mlog(n + m)。

注意这里没有点权，只有边权，而且边全都给出来了，我们就对于每个边新建一个点代表它就行了...具体看代码。

// NOI 2014 mofa forest
#include <cstdio>
#include <algorithm>

const int N = 50010, M = 100010, INF = 0x7f7f7f7f;

inline void read(int &x) {
    char c = getchar();
    bool f = 0;
    while(c < '0' || c > '9') {
        if(c == '-') {
            f = 1;
        }
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = (x << 3) + (x << 1) + c - 48;
        c = getchar();
    }
    if(f) {
        x = -x;
    }
    return;
}

struct Edge {
    int u, v;
    int a, b;
    inline bool operator <(const Edge &d) const {
        if(a != d.a) {
            return a < d.a;
        }
        return b < d.b;
    }
}edge[M];

struct UFS {
    int fa[N + M];

    inline void clear() {
        for(int i = 1; i < N + M; i++) {
            fa[i] = i;
        }
        return;
    }

    UFS() {
        clear();
    }

    inline int find(int x) {
        if(fa[x] == x) {
            return x;
        }
        return fa[x] = find(fa[x]);
    }

    inline void merge(int x, int y) {
        fa[find(x)] = find(y);
        return;
    }

    inline bool check(int x, int y) {
        return find(x) == find(y);
    }
}ufs;

struct LCT {
    int val[N + M], fa[N + M], s[N + M][2], large[N + M], stk[N + M], t;
    bool rev[N + M];

    inline int no_root(int x) {
        return s[fa[x]][0] == x || s[fa[x]][1] == x;
    }

    inline void pushup(int x) {
        large[x] = x;
        if(val[large[x]] < val[large[s[x][0]]]) {
            large[x] = large[s[x][0]];
        }
        if(val[large[x]] < val[large[s[x][1]]]) {
            large[x] = large[s[x][1]];
        }
        return;
    }

    inline void pushdown(int x) {
        if(!rev[x]) {
            return;
        }
        if(s[x][0]) {
            rev[s[x][0]] ^= 1;
        }
        if(s[x][1]) {
            rev[s[x][1]] ^= 1;
        }
        std::swap(s[x][0], s[x][1]);
        rev[x] = 0;
        return;
    }

    inline void rotate(int x) {
        int y = fa[x];
        int z = fa[y];
        bool f = (s[y][1] == x);

        fa[x] = z;
        if(no_root(y)) {
            s[z][s[z][1] == y] = x;
        }
        s[y][f] = s[x][!f];
        fa[s[x][!f]] = y;
        s[x][!f] = y;
        fa[y] = x;

        pushup(y);
        pushup(x);
        return;
    }

    inline void splay(int x) {
        int y = x;
        stk[++t] = x;
        while(no_root(y)) {
            y = fa[y];
            stk[++t] = y;
        }
        while(t) {
            pushdown(stk[t]);
            t--;
        }
        y = fa[x];
        int z = fa[y];
        while(no_root(x)) {
            if(no_root(y)) {
                (s[z][1] == y) ^ (s[y][1] == x) ?
                rotate(x) : rotate(y);
            }
            rotate(x);
            y = fa[x];
            z = fa[y];
        }
        return;
    }

    inline void access(int x) {
        int y = 0;
        while(x) {
            splay(x);
            s[x][1] = y;
            pushup(x);
            y = x;
            x = fa[x];
        }
        return;
    }

    inline int findroot(int x) {
        access(x);
        splay(x);
        pushdown(x);
        while(s[x][0]) {
            x = s[x][0];
            pushdown(x);
        }
        return x;
    }

    inline void makeroot(int x) {
        access(x);
        splay(x);
        rev[x] = 1;
        return;
    }

    inline void link(int x, int y) {
        makeroot(x);
        if(findroot(y) != x) {
            fa[x] = y;
        }
        return;
    }

    inline void cut(int x, int y) {
        makeroot(x);
        access(y);
        splay(y);
        if(s[y][0] == x && fa[x] == y && s[x][1] == 0) {
            fa[x] = 0;
            s[y][0] = 0;
            pushup(y);
        }
        return;
    }

    inline int getmax(int x, int y) {
        makeroot(x);
        access(y);
        splay(y);
        return large[y];
    }
}lct;

int main()  {
    int n, m, ans = INF;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++) {
        read(edge[i].u);
        read(edge[i].v);
        read(edge[i].a);
        read(edge[i].b);
    }
    std::sort(edge + 1, edge + m + 1);
    for(int i = 1; i <= m; i++) {
        lct.val[i + n] = edge[i].b;
    }

    for(int i = 1; i <= m; i++) {
        int x = edge[i].u;
        int y = edge[i].v;
        //printf("%d - %d  a = %d  b = %d  
", x, y, edge[i].a, edge[i].b);
        if(ufs.check(x, y)) {
            int t = lct.getmax(x, y);
            if(lct.val[t] > edge[i].b) {
                lct.cut(edge[t - n].u, t);
                lct.cut(edge[t - n].v, t);
                lct.link(x, i + n);
                lct.link(y, i + n);
                if(ufs.check(1, n)) {
                    ans = std::min(ans, edge[i].a + lct.val[lct.getmax(1, n)]);
                }
                //printf("1 : ans = %d 
", ans);
            }
        }
        else {
            ufs.merge(x, y);
            lct.link(x, i + n);
            lct.link(y, i + n);
            if(ufs.check(1, n)) {
                ans = std::min(ans, edge[i].a + lct.val[lct.getmax(1, n)]);
                //printf("2 : ans = %d 
", ans);
            }
        }
    }
    printf("%d", ans == INF ? -1 : ans);
    return 0;
}

update：前面15分是搜索，50分是枚举一条边，暴力维护生成树。70分是枚举a的取值，并查集维护。看代码吧。

#include <bits/stdc++.h>

const int N = 200010, INF = 0x3f3f3f3f;

struct Edge {
    int nex, v, a, b, pre;
}edge[N << 1]; int tp = 1;

struct Node {
    int a, b, x, y;
    inline bool operator < (const Node &w) const {
        return a < w.a;
    }
}node[N << 1];

int e[N], n, m;
std::multiset<int> st;

inline void add(int x, int y, int a, int b) {
    tp++;
    edge[tp].v = y;
    edge[tp].a = a;
    edge[tp].b = b;
    edge[tp].nex = e[x];
    if(e[x]) edge[e[x]].pre = tp;
    e[x] = tp;
    return;
}

inline void del(int x, int i) {
    if(!edge[i].nex && e[x] == i) {
        e[x] = 0;
    }
    else if(!edge[i].nex) {
        edge[edge[i].pre].nex = 0;
    }
    else if(e[x] == i) {
        e[x] = edge[i].nex;
        edge[e[x]].pre = 0;
    }
    else {
        edge[edge[i].pre].nex = edge[i].nex;
        edge[edge[i].nex].pre = edge[i].pre;
    }
    return;
}

inline void Link() {
    for(int i = 1; i <= m; i++) {
        add(node[i].x, node[i].y, node[i].a, node[i].b);
        add(node[i].y, node[i].x, node[i].a, node[i].b);
    }
    return;
}

namespace bf {
    int ans = INF;
    bool vis[N];
    void DFS(int x, int a, int b) {
        if(x == n) {
            ans = std::min(ans, a + b);
            return;
        }
        vis[x] = 1;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(vis[y]) continue;
            DFS(y, std::max(a, edge[i].a), std::max(b, edge[i].b));
        }
        vis[x] = 0;
        return;
    }
    inline void solve() {
        Link();
        DFS(1, 0, 0);
        if(ans == INF) ans = -1;
        printf("%d
", ans);
        return;
    }
}

namespace ufs {
    int fa[N];
    inline void init() {
        for(int i = 1; i <= n; i++) fa[i] = i;
        return;
    }
    int find(int x) {
        if(fa[x] == x) return x;
        return fa[x] = find(fa[x]);
    }
    inline void merge(int x, int y) {
        fa[find(x)] = find(y);
        return;
    }
    inline bool check(int x, int y) {
        return find(x) == find(y);
    }
}

namespace bf2 {
    int Time, large, pos, vis[N];
    bool DFS(int x, int t) {
        if(x == t) return true;
        vis[x] = Time;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(vis[y] == Time) continue;
            if(DFS(y, t)) {
                if(large < edge[i].b) {
                    large = edge[i].b;
                    pos = i;
                }
                return true;
            }
        }
        return false;
    }
    int getMax(int x) {
        if(x == n) return 0;
        vis[x] = Time;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(vis[y] == Time) continue;
            int t = getMax(y);
            if(t == -1) continue;
            return std::max(t, edge[i].b);
        }
        return -1;
    }
    inline void solve() {
        int ans = INF;
        ufs::init();
        for(int i = 1; i <= m; i++) {
            int x = node[i].x, y = node[i].y;
            if(ufs::check(x, y)) {
                large = -1;
                ++Time;
                DFS(x, y);
                if(large <= node[i].b) continue;
                del(edge[pos ^ 1].v, pos);
                del(edge[pos].v, pos ^ 1);
                add(x, y, node[i].a, node[i].b);
                add(y, x, node[i].a, node[i].b);
            }
            else {
                ufs::merge(x, y);
                add(x, y, node[i].a, node[i].b);
                add(y, x, node[i].a, node[i].b);
            }
            if(ufs::check(1, n)) {
                ++Time;
                int temp = getMax(1);
                ans = std::min(ans, node[i].a + temp);
            }
        }
        if(ans == INF) ans = -1;
        printf("%d
", ans);
        return;
    }
}

namespace bf3 {
    inline bool cmp(const Node &x, const Node &y) {
        return x.b < y.b;
    }
    inline void solve() {
        std::sort(node + 1, node + m + 1, cmp);
        int ans = INF;
        for(int lim = 1; lim <= 30; lim++) {
            ufs::init();
            int temp = INF;
            for(int i = 1; i <= m; i++) {
                if(node[i].a > lim) {
                    continue;
                }
                ufs::merge(node[i].x, node[i].y);
                if(ufs::check(1, n)) {
                    temp = node[i].b;
                    break;
                }
            }
            ans = std::min(ans, lim + temp);
        }
        if(ans == INF) ans = -1;
        printf("%d
", ans);
        return;
    }
}

namespace lct {
    int fa[N], s[N][2], large[N], val[N], stk[N], top;
    bool rev[N];
    inline bool no_root(int x) {
        return s[fa[x]][0] == x || s[fa[x]][1] == x;
    }
    inline void pushup(int x) {
        large[x] = x;
        if(s[x][0] && val[large[x]] < val[large[s[x][0]]]) {
            large[x] = large[s[x][0]];
        }
        if(s[x][1] && val[large[x]] < val[large[s[x][1]]]) {
            large[x] = large[s[x][1]];
        }
        return;
    }
    inline void pushdown(int x) {
        if(rev[x]) {
            if(s[x][0]) rev[s[x][0]] ^= 1;
            if(s[x][1]) rev[s[x][1]] ^= 1;
            std::swap(s[x][0], s[x][1]);
            rev[x] = 0;
        }
        return;
    }
    inline void rotate(int x) {
        int y = fa[x];
        int z = fa[y];
        bool f = (s[y][1] == x);

        fa[x] = z;
        if(no_root(y)) {
            s[z][s[z][1] == y] = x;
        }
        s[y][f] = s[x][!f];
        if(s[x][!f]) {
            fa[s[x][!f]] = y;
        }
        s[x][!f] = y;
        fa[y] = x;

        pushup(y);
        return;
    }
    inline void splay(int x) {
        int y = x;
        stk[top = 1] = y;
        while(no_root(y)) {
            y = fa[y];
            stk[++top] = y;
        }
        while(top) {
            pushdown(stk[top]);
            top--;
        }

        y = fa[x];
        int z = fa[y];
        while(no_root(x)) {
            if(no_root(y)) {
                (s[z][1] == y) ^ (s[y][1] == x) ?
                rotate(x) : rotate(y);
            }
            rotate(x);
            y = fa[x];
            z = fa[y];
        }
        pushup(x);
        return;
    }
    inline void access(int x) {
        int y = 0;
        while(x) {
            splay(x);
            s[x][1] = y;
            pushup(x);
            y = x;
            x = fa[x];
        }
        return;
    }
    inline void make_root(int x) {
        access(x);
        splay(x);
        rev[x] ^= 1;
        return;
    }
    inline int find_root(int x) {
        access(x);
        splay(x);
        while(s[x][0]) {
            x = s[x][0];
            pushdown(x);
        }
        splay(x);
        return x;
    }
    inline void link(int x, int y) {
        make_root(x);
        fa[x] = y;
        return;
    }
    inline void cut(int x, int y) {
        make_root(x);
        access(y);
        splay(y);
        fa[x] = s[y][0] = 0;
        pushup(y);
        return;
    }
    inline int ask(int x, int y) {
        make_root(x);
        access(y);
        splay(y);
        return large[y];
    }
}

int main() {
    scanf("%d%d", &n, &m);
    int largeA = -1;
    for(int i = 1; i <= m; i++) {
        scanf("%d%d%d%d", &node[i].x, &node[i].y, &node[i].a, &node[i].b);
        largeA = std::max(largeA, node[i].a);
    }
    std::sort(node + 1, node + m + 1);
    if(n <= 5 && m <= 10) {
        bf::solve();
        return 0;
    }
    if(n <= 5000 && m <= 10000) {
        bf2::solve();
        return 0;
    }
    if(largeA <= 30) {
        bf3::solve();
        return 0;
    }
    /// lct solve
    int ans = INF;
    ufs::init();
    for(int i = 1; i <= m; i++) {
        lct::val[n + i] = node[i].b;
    }
    for(int i = 1; i <= m; i++) {
        int x = node[i].x, y = node[i].y;
        if(ufs::check(x, y)){
            int t = lct::ask(x, y);
            if(lct::val[t] <= node[i].b) continue;
            lct::cut(t, node[t - n].x);
            lct::cut(t, node[t - n].y);
            lct::link(x, n + i);
            lct::link(y, n + i);
        }
        else {
            lct::link(x, n + i);
            lct::link(y, n + i);
            ufs::merge(x, y);
        }
        if(ufs::check(1, n)) {
            ans = std::min(ans, node[i].a + lct::val[lct::ask(1, n)]);
        }
    }
    if(ans == INF) ans = -1;
    printf("%d
", ans);
    return 0;
}