【洛谷P2387】魔法森林

题目大意：给定一个 N 个点，M 条边的无向图，边有两个边权 a, b，求从 1 号节点到 N 号节点路径的两个权值和的最大值最小是多少。

题解：
对于有两个属性的结构的最优化问题，可以考虑先按照其中一个分量进行排序。接着从小到大枚举这个有序的分量，计算以当前枚举到的值为这一分量的最大值时，全局的最优解是多少。因此，需要高效维护的是如何求出另一个分量的最优解。

对于这道题来说，考虑对 a 分量进行排序，并按从小到大的顺序依次加边。对于即将加入的第 i 条边来说，若加入这条边使得两个本来不联通的点联通，则直接加入；若加入这条边之后，形成了环，则比较加入这条边 b 的权值和这条边两个端点之间路径上 b 的最大值，若当前边的 b 更小，则断开路径上最大边权的边，并加入当前这条边即可。利用 lct 进行维护 b 即可。

代码如下

#include <bits/stdc++.h>

using namespace std;

struct edge {
    int x, y, a, b;
    edge(int _x = 0, int _y = 0, int _a = 0, int _b = 0) {
        x = _x, y = _y;
        a = _a, b = _b;
    }
};

struct node {
    node* l;
    node* r;
    node* p;
    int rev, b, maxb, id;
    node(int _b = 0, int _id = -1) {
        l = r = p = NULL;
        b = _b;
        id = _id;
        rev = 0;
    }
    void unsafe_reverse() {
        swap(l, r);
        rev ^= 1;
    }
    void pull() {
        maxb = b;
        if (l != NULL) {
            l->p = this;
            maxb = max(maxb, l->maxb);
        }
        if (r != NULL) {
            r->p = this;
            maxb = max(maxb, r->maxb);
        }
    }
    void push() {
        if (rev) {
            if (l != NULL) {
                l->unsafe_reverse();
            } 
            if (r != NULL) {
                r->unsafe_reverse();
            }
            rev = 0;
        }
    }
};
bool is_root(node* v) {
    if (v == NULL) {
        return false;
    }
    return (v->p == NULL) || (v->p->l != v && v->p->r != v);
}
void rotate(node* v) {
    node* u = v->p;
    assert(u != NULL);
    v->p = u->p;
    if (v->p != NULL) {
        if (v->p->l == u) {
            v->p->l = v;
        }
        if (v->p->r == u) {
            v->p->r = v;
        }
    }
    if (v == u->l) {
        u->l = v->r;
        v->r = u;
    }
    if (v == u->r) {
        u->r = v->l;
        v->l = u;
    }
    u->pull();
    v->pull();
}
void deal_with_push(node* v) {
    static stack<node*> s;
    while (true) {
        s.push(v);
        if (is_root(v)) {
            break;
        }
        v = v->p;
    }
    while (!s.empty()) {
        s.top()->push();
        s.pop();
    }
}
void splay(node* v) {
    deal_with_push(v);
    while (!is_root(v)) {
        node* u = v->p;
        if (!is_root(u)) {
            if ((v == u->l) ^ (u == u->p->l)) {
                rotate(v);
            } else {
                rotate(u);
            }
        }
        rotate(v);
    }
}
void access(node* v) {
    node* u = NULL;
    while (v != NULL) {
        splay(v);
        v->r = u;
        v->pull();
        u = v;
        v = v->p;
    }
}
void make_root(node* v) {
    access(v);
    splay(v);
    v->unsafe_reverse();
}
node* find_root(node* v) {
    access(v);
    splay(v);
    while (v->l != NULL) {
        v->push();
        v = v->l;
    }
    splay(v);
    return v;
}
void link(node* v, node* u) {
    if (find_root(v) != find_root(u)) {
        make_root(v);
        v->p = u;
    }
}
void cut(node* v, node* u) {
    make_root(v);
    if (find_root(u) == v && u->p == v && u->l == NULL) {
        u->p = v->r = NULL;
        v->pull();
    }
}
void split(node* v, node* u) {
    make_root(v);
    access(u);
    splay(u);
}
node* find(node* v, int b) {
    while (true) {
        if (v->b == b) {
            break;
        }
        if (v->l != NULL && v->l->maxb == b) {
            v = v->l;
        } else {
            v = v->r;
        }
    }
    return v;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int n, m; // 0-indexed
    cin >> n >> m;
    vector<edge> e;
    for (int i = 0; i < m; i++) {
        int x, y, a, b;
        cin >> x >> y >> a >> b;
        e.emplace_back(--x, --y, a, b);
    }
    sort(e.begin(), e.end(), [&](const edge &x, const edge &y) {
        return x.a < y.a;
    });
    vector<node*> t(n + m);
    for (int i = 0; i < n; i++) {
        t[i] = new node(0, i);
    }
    int ans = 1e9;
    for (int i = 0; i < m; i++) {
        int a = e[i].a, b = e[i].b;
        int x = e[i].x, y = e[i].y;
        if (find_root(t[x]) != find_root(t[y])) {
            t[i + n] = new node(b, i + n);
            link(t[x], t[i + n]);
            link(t[y], t[i + n]);
        } else {
            split(t[x], t[y]);
            if (b < t[y]->maxb) {
                node* v = find(t[y], t[y]->maxb);
                int id = v->id - n;
                int vx = e[id].x, vy = e[id].y;
                cut(t[vx], v), cut(t[vy], v);
                t[i + n] = new node(b, i + n);
                link(t[x], t[i + n]);
                link(t[y], t[i + n]);
            }
        }
        if (find_root(t[0]) == find_root(t[n - 1])) {
            split(t[0], t[n - 1]);
            ans = min(ans, a + t[n - 1]->maxb);
        }
    }
    if (ans == 1e9) {
        cout << "-1" << endl;
    } else {
        cout << ans << endl;
    }
    return 0;
} 

转载于:https://www.cnblogs.com/wzj-xhjbk/p/11593857.html