P4180 严格次小生成树[BJWC2010] Kruskal，倍增

Posted 2021-10-30 maomao9173

题目链接\(Click\) \(Here\)。

题意就是要求一个图的严格次小生成树。以前被题面吓到了没敢做，写了一下发现并不难。

既然要考虑次小我们就先考虑最小。可以感性理解到一定有一种次小生成树，可以由最小生成树删一条边再加一条边得到。我们枚举加上去的这一条边，加上去以后原\(mst\)会成为一个基环树，想让它次小就在这个环里找一条最长的边（不包含新加进去的）删掉就好。放在树上来讲，就是找到\(u\)到\(v\)路径上的最大值。这样我们就有了非严格次小生成树。

严格要怎么处理？我们需要排除新加上的边和\(u\)到\(v\)路径最长边相等的情况。仔细思考会发现可以再倍增维护一个次大长度，如果最大长度严格小于新加上边的长度就选用最大，否则就用次大。

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int N = 100000 + 5;
const int M = 300000 + 5;
const int INF = 0x7fffffff;
const LL INFF = 0x7fffffffffffffff;

struct Graph {
    
    int cnt, head[N];

    struct Edge {int nxt, to, w;}e[N << 1];

    void clear () {
        cnt = -1;
        memset (head, -1, sizeof (head));
    }
    
    void add_len (int u, int v, int w) {
        e[++cnt] = (Edge) {head[u], v, w}; head[u] = cnt;
        e[++cnt] = (Edge) {head[v], u, w}; head[v] = cnt; 
    }
    
    int deep[N], pre[N][20], w1st[N][20], w2nd[N][20];
    
    void dfs (int u, int fa) {
        deep[u] = deep[fa] + 1;
        for (int i = head[u]; ~i; i = e[i].nxt) {
            int v = e[i].to;
            if (v != fa) {
                dfs (v, u);
                pre[v][0] = u;
                w2nd[v][0] = -INF;
                w1st[v][0] = e[i].w;
            }
        }
    }
    
    void build (int u) {
        for (int i = 1; (1 << i) <= deep[u]; ++i) {
            pre[u][i] = pre[pre[u][i - 1]][i - 1];
            w1st[u][i] = max (w1st[u][i - 1], w1st[pre[u][i - 1]][i - 1]);
            w2nd[u][i] = max (w2nd[u][i - 1], w2nd[pre[u][i - 1]][i - 1]);
            if (w1st[u][i - 1] < w1st[pre[u][i - 1]][i - 1]) {
                w2nd[u][i] = max (w2nd[u][i], w1st[u][i - 1]);
            }
            if (w1st[u][i - 1] > w1st[pre[u][i - 1]][i - 1]) {
                w2nd[u][i] = max (w2nd[u][i], w1st[pre[u][i - 1]][i - 1]);
            }
        }
        for (int i = head[u]; ~i; i = e[i].nxt) {
            if (e[i].to != pre[u][0]) build (e[i].to);
        }
    }
    
    int lca (int u, int v) {
        if (deep[u] < deep[v]) swap (u, v);
        for (int i = 19; i >= 0; --i) {
            if (deep[u] - deep[v] >= (1 << i)) {
                u = pre[u][i];
            }
        }
        if (u == v) return u;
        for (int i = 19; i >= 0; --i) {
            if (pre[u][i] != pre[v][i]) {
                u = pre[u][i];
                v = pre[v][i];
            }
        }
        return pre[u][0];
    }
    
    int query (int u, int v, int w) {
        //求u到v之间严格小于w的最大的值 
        int ans = -INF;
        for (int i = 19; i >= 0; --i) {
            if (deep[v] - deep[u] >= (1 << i)) {
                if (w1st[v][i] < w) {
                    ans = max (ans, w1st[v][i]);
                } else {
                    ans = max (ans, w2nd[v][i]);
                }
                v = pre[v][i];
            }
        }
        return ans;
    }
    
}G; 

struct Len {
    int u, v, w;
    
    bool operator < (Len rhs) const {
        return w < rhs.w;
    }
    
    Len () {} 
    Len (int u, int v, int w) : u(u), v(v), w(w) {}
}arr[M];

int n, m, Set[N], in_mst[M];

int find (int x) {
    return x == Set[x] ? x : (Set[x] = find (Set[x]));
}

int main () {
    G.clear (); 
    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        static int u, v, w;
        cin >> u >> v >> w;
        arr[i] = Len (u, v, w);
    }
    sort (arr, arr + m);
    for (int i = 0; i <= n; ++i) Set[i] = i;
    LL mstw = 0;
    for (int i = 0; i < m; ++i) {
        int u = arr[i].u;
        int v = arr[i].v;
        int w = arr[i].w;
        if (find (u) != find (v)) {
            mstw += w;
            in_mst[i] = true; 
            G.add_len (u, v, w);
            Set[find (u)] = find (v);
        }
    }
    G.w1st[1][0] = -INF;
    G.dfs (1, 0);
    G.build (1);
    LL ans = INFF; 
    for (int i = 0; i < m; ++i) {
        if (!in_mst[i]) {
            int u = arr[i].u; 
            int v = arr[i].v;
            int w = arr[i].w;
            int _lca = G.lca (u, v);
            int maxu = G.query (_lca, u, w);
            int maxv = G.query (_lca, v, w);
            ans = min (ans, mstw + w - max (maxu, maxv));
        }
    } 
    cout << ans << endl; 
}