严格次小生成树 洛谷P4180题解

先粘代码，后期更新原理。

#include <cstdio>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;

#define MaxN 100005
#define MaxM 300005
#define LogN 20
#define INF 0x7fffffffffffffffLL

int N, M;

struct EDGE{
    int x, y, f;
    long long z;
    bool operator < (const EDGE &b) const{
        return z < b.z;
    }
}edge[MaxM];

inline long long max(long long a, long long b){
    return a>b ? a : b;
}

inline long long max(long long a, long long b, long long c){
    return max(a, max(b, c));
}

int point[MaxN], tot;
int nxt[MaxM], v[MaxM];
long long w[MaxM];
inline void add(int x, int y, long long z){
    ++tot; nxt[tot] = point[x];
    v[tot] = y; w[tot] = z;
    point[x] = tot;
}

int fa[MaxN];
inline int find(int x){
    return fa[x] == x ? fa[x] : fa[x] = find(fa[x]);
}

long long ans, _ans;
void Kruskal(){
    sort(edge+1, edge+1+M);
    for(register int i = 1; i<=N; ++i) fa[i] = i;
    for(register int i = 1; i<=M; ++i){
        int fx = find(edge[i].x);
        int fy = find(edge[i].y);
        if(fx == fy) continue;
        fa[fx] = fy;
        add(edge[i].x, edge[i].y, edge[i].z);
        add(edge[i].y, edge[i].x, edge[i].z);
        ans += (long long)edge[i].z;
        edge[i].f = 1;
    }
}

int deep[MaxN];
bool flag[MaxN];
int f[MaxN][LogN];
long long g[MaxN][LogN];
long long h[MaxN][LogN];

void dfs(int node, int ff, long long ww, int d){
    deep[node] = d;
    f[node][0] = ff;
    g[node][0] = ww;
    flag[node] = true;
    for(register int i = point[node]; i; i = nxt[i]){
        if(flag[v[i]]) continue;
        dfs(v[i], node, w[i], d+1);
    }
}

struct RES{
    long long max, maxx;
};

RES max_maxx(long long g1, long long g2, long long h1, long long h2){
    RES res;
    if(g1 == g2){
        res.max = g1;
        res.maxx = max(h1, h2);
    }else if(g1 > g2){
        res.max = g1;
        res.maxx = max(g2, h1, h2);
    }else{
        res.max = g2;
        res.maxx = max(g1, h1, h2);
    }
    return res;
}

void process(){
    for(register int j = 1; j<LogN; ++j)
        for(register int i = 1; i<=N; ++i){
            f[i][j] = f[f[i][j-1]][j-1];
            RES res = max_maxx(g[i][j-1], g[f[i][j-1]][j-1], h[i][j-1], h[f[i][j-1]][j-1]);
            g[i][j] = res.max;
            h[i][j] = res.maxx;
        }
}

RES find_LCA(int x, int y){
    RES res = (RES){-1, -1}, tmp = (RES){-1, -1};
    if(deep[x]<deep[y]) swap(x, y);
    for(register int j = LogN-1; j>=0; --j){
        if(deep[f[x][j]]>=deep[y]){
            res = max_maxx(g[x][j], res.max, h[x][j], res.maxx);
            x = f[x][j];
        }
    }
    if(x == y) return res;
    for(register int j = LogN-1; j>=0; --j){
        if(f[x][j] != f[y][j]){
            tmp = max_maxx(g[x][j], g[y][j], h[x][j], h[y][j]);
            res = max_maxx(tmp.max, res.max, tmp.maxx, res.maxx);
            x = f[x][j];
            y = f[y][j];
        }
    }
    tmp = max_maxx(g[x][0], g[y][0], h[x][0], h[y][0]);
    res = max_maxx(tmp.max, res.max, tmp.maxx, res.maxx);
    return res;
}

inline long long read(){
    register long long ans = 0;
    register char c;
    while((c = getchar())==' ' || c=='\n' || c=='\r');
    while((c = getchar())>='0' && c<='9') ans = (ans<<1) + (ans<<3) + c -'0';
    return ans;
}

int main(){
    scanf("%d %d", &N, &M);
    for(register int i = 1; i<=M; ++i) scanf("%d %d %lld", &edge[i].x, &edge[i].y, &edge[i].z);
    for(register int i = 0; i<=N; ++i)
        for(register int j = 0; j<LogN; ++j)
            g[i][j] = h[i][j] = -1;
    Kruskal();
    dfs(1, 0, -1, 1);
    process();
    _ans = INF;
    for(register int i = 1; i<=M; ++i){
        if(edge[i].f) continue;
        RES res = find_LCA(edge[i].x, edge[i].y);
        long long _max = res.max == edge[i].z ? res.maxx : res.max;
        if(_max == -1) continue;
        long long tmp = ans + edge[i].z - _max;
        if(tmp> ans && tmp < _ans) _ans = tmp;
    }
    printf("%lld\n", _ans);
    return 0;
}