次小生成树

#include <bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
typedef long long ll;
const int M=300001;
const int N=100001;
struct node {
    int u, v, w, k;
    bool operator<(const node &b) const {
        return w < b.w;
    }
}a[M];
struct node1 {
    int to,next,w;
}e[M];
int n,m,mn=inf,t,head[N],f[N][20],d1[N][20],d2[N][20],deep[N];

void add(int u,int v,int w){
    t++;
    e[t].to=v;
    e[t].w=w;
    e[t].next=head[u];
    head[u]=t;
}

struct Kurskal {
    int n, m,f[N];
    int find(int x) {
        return x == f[x] ? x : f[x] = find(f[x]);
    }

    ll kurskal() {
        int k = 0;
        ll ans=0;
        sort(a + 1, a + m + 1);
        for (int i = 1; i <= m; i++) {
            int x = find(a[i].u), y = find(a[i].v);
            if (x != y) {
                ans += a[i].w;
                a[i].k=1;
                add(a[i].u, a[i].v, a[i].w);
                add(a[i].v, a[i].u, a[i].w);
                f[x] = y;
                k++;
                if (k == n - 1) {
                    break;
                }
            }
        }
        return ans;
    }

    void init(int n, int m) {
        this->n = n;
        this->m = m;
        for (int i = 1; i <= n; i++) {
            f[i] = i;
        }
        for (int i = 1; i <= m; i++) {
            scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
        }
    }
} K;


void dfs(int x,int fa) {
    for (int i = 1; i <= 16; i++) {
        if (deep[x] < (1 << i)) break;
        f[x][i] = f[f[x][i - 1]][i - 1];
        d1[x][i] = max(d1[x][i - 1], d1[f[x][i - 1]][i - 1]);
        if (d1[x][i - 1] == d1[f[x][i - 1]][i - 1]) {
            d2[x][i] = max(d2[x][i - 1], d2[f[x][i - 1]][i - 1]);
        } else {
            d2[x][i] = min(d1[x][i - 1], d1[f[x][i - 1]][i - 1]);
            d2[x][i] = max(d2[x][i - 1], d2[x][i]);
            d2[x][i] = max(d2[x][i], d2[f[x][i - 1]][i - 1]);
        }
    }
    for (int i = head[x]; i; i = e[i].next) {
        int to = e[i].to;
        if (to != fa) {
            f[to][0] = x;
            d1[to][0] = e[i].w;
            deep[to] = deep[x] + 1;
            dfs(to, x);
        }
    }
}


int lca(int x,int y) {
    if (deep[x] < deep[y]) {
        swap(x, y);
    }
    int h = deep[x] - deep[y], k = 0;
    while (h) {
        if (h & 1) {
            x = f[x][k];
        }
        h >>= 1;
        k++;
    }
    if (x == y) {
        return x;
    }
    for (int k = 19; k >= 0; k--) {
        if (f[x][k] != f[y][k]) {
            x = f[x][k];
            y = f[y][k];
        }
    }
    return f[x][0];
}


void cal(int x,int fa,int v) {
    int mx1 = 0,mx2 = 0;
    int h = deep[x] - deep[fa];
    for (int i = 0; i <= 16; i++) {
        if (h & (1 << i)) {
            if (d1[x][i] > mx1) {
                mx2 = mx1;
                mx1 = d1[x][i];
            }
            mx2 = max(mx2, d2[x][i]);
            x = f[x][i];
        }
    }
    if (mx1 != v) {
        mn = min(mn, v - mx1);
    } else {
        mn = min(mn, v - mx2);
    }
}

void solve(int i,int v){
    int x=a[i].u,y=a[i].v,f=lca(x,y);
    cal(x,f,v);
    cal(y,f,v);
}

int main() {
    scanf("%d%d", &n, &m);
    K.init(n,m);
    ll ans = K.kurskal();
    dfs(1, 0);
    for (int i = 1; i <= m; i++) {
        if (!a[i].k) {
            solve(i, a[i].w);
        }
    }
    printf("%lld
", ans + mn);
    return 0;
}

#include<bits/stdc++.h>

次小生成树
求最小生成树时用数组Max[i][j]来表示MST中i到j最大边权
求完后直接枚举所有不在MST中的边，替换掉最大边权的边，更新答案

int prim(int cost[][maxn],int n) {
    int ans = 0;
    memset(vis, 0, sizeof(vis));
    memset(Max, 0, sizeof(Max));
    memset(used, 0, sizeof(used));
    v[0] = 1;
    pre[0] = -1;
    for (int i = 1; i <= n; i++) {
        lowc[i] = cost[0][i];
        pre[i] = 0;
    }
    lowc[0] = 0;
    for (int i = 1; i < n; i++) {
        int minc = inf;
        int p = -1;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && minc > lowc[j]) {
                minc = lowc[j];
                p = j;
            }
        }
        if (minc == inf) {
            return -1;
        }
        ans += minc;
        vis[p] = 1;
        used[p][pre[p]] = used[pre[p]][p] = 1;
        for (int j = 0; j < n; j++) {
            if (vis[j] && j != p) {
                Max[j][p] = Max[p][j] = max(Max[j][pre[p]], lowc[p]);
            }
            if (!vis[j] && lowc[j] > cost[p][j]) {
                lowc[j] = cost[p][j];
                pre[j] = p;
            }
        }
    }
    return ans;
}
        
    }
}