最小生成树

首先介绍两个求最小生成树的算法：Kruskal 和 Prime

Kruskal

Kruskal算法流程：O(m*log m)

1. 建立并查集，每个点各自构成一个集合
2. 将所有边按边权升序排列，依次扫描每条边
3. 如果这条边的两个点属于同一个集合，忽略
4. 否则，合并两个集合，并将边权累加入答案

Kruskal 实现代码

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

const int N = 1e5 + 10, M = 2e5 + 10;

struct Edge
{
    int a, b, w;
    bool operator < (const Edge& W) const
    {
        return w < W.w;
    }
    
}edges[M];
int n, m;
int p[N];

int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++) p[i] = i;
    for(int i = 0; i < m; i++)
    {
        int a, b, c; cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }
    sort(edges, edges + m);
    int res = 0, cnt = 0;
    for(int i = 0; i < m; i++)
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        int pa = find(a), pb = find(b);
        
        if(pa != pb)
        {
            cnt++;
            res += w;
            p[pa] = pb;
        }
    }
    if(cnt < n - 1) cout << "impossible" << endl;
    else cout << res << endl;
    return 0;
}

Prim

Prim算法可以类比Dijkstra算法，也可以分为朴素版和堆优化版。
但是堆优化版不然Kruskal算法简便，所以说只有当稠密图的时候使用Prim算法，尤其是完全图的时候。

时间复杂度：O(n ^ 2) 

与 Dijkstra 不同的是，Prim 每次确定的是集合与点之间的最小距离，Dijkstra 每次确定的是起点和该点的最小距离。当该点最小距离确定之后，st 数组设为 true。

Prime代码实现

#include <iostream>
#include <cstring>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int dist[N], g[N][N];
bool st[N];

void Prime()
{
    int res = 0;
    memset(dist, 0x3f, sizeof dist);
    for(int i = 0; i < n; i++)
    {
        int t = -1;
        for(int j = 1; j <= n; j++)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        if(i) res += dist[t];
        if(i && dist[t] == INF) { cout << "impossible" << endl; return; }
        st[t] = true;
        
        for(int j = 1; j <= n; j++)
            dist[j] = min(dist[j], g[t][j]);
    }
    cout << res << endl;
}

int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    for(int i = 1; i <= n; i++) g[i][i] = 0;
    for(int i = 0; i < m; i++)
    {
        int a, b, c; cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    Prime();
    return 0;
}

次小生成树

次小生成树分为：严格次小生成树和非严格次小生成树。

次小生成树的定义：给定一个带权的图，将图的所有生成树按总权值从小到大排序，第二小的就是次小生成树。而严格之分就是，严格次小生成树的权值和大于最小生成树的权值和，非严格可以等于。

方法1：先求出最小生成树，然后依次删除最小生成的边，再求解最小生成树。
时间复杂度分析：求最小生成树先按边权排序，然后依次删边，共删 n - 1 条边，然后依次求最小生成树，但是边排序只需要最初排序就行。O(mlogm + nm)
该法的缺陷是无法求出严格次小生成树；因为每次删边之后求最小生成树，如果有和最小生成树相同的边权，那么一定会得到和最小生成树相同的边权，无法得到严格次小生成树。

方法2：先求出最小生成树，然后依次将非树边加入树中，并且去掉树中一条边，使得仍是一颗树。

证明如下：
        定义1：设 T 为图 G 的一颗生成树，对于非树边 a 和树边 b，令插入边 a 记为 +a，删除边 b 记为 -b；如果 T+a-b 之后，仍是一颗生成树，那么称为一个可行交换。
        定义2：称由 T 进行的一次可行交换所得到的生成树集合为 T 的邻集。
        定理：次小生成树一定在最小生成树的邻集中。

该算法步骤：

1. 求最小生成树，并标记最小生成树的树边，建立一颗最小生成树，累计权值（sum）
2. 在最小生成树中求任意两点的路径上的最大边权和次大边权（dist1[][], dist2[][]）（树中任意两点的路径唯一）
3. 依次枚举非最小生成树树边，尝试用该边替代最小生成树中最长的边（两边的端点相同，才能使替代之后仍是一颗生成树），非树边一定大于等于树边（若小于，那么可以替代树边使得生成树的权值更小，与最小生成矛盾）
4. 设非树边的权值为 t，端点为 a、b，A = dist1[a][b]，B = dist2[a][b]；t > A，替代 A；t = A && t > B 替代 B （这就是方法2能求出严格次小生成的原因，方法1不能处理相等的情况）

代码实现

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
using LL = long long;

const int N = 510, M = 2e4 + 10;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int p[N];
int dist1[N][N], dist2[N][N];
struct Edge
{
    int a, b, c;
    bool f;
    bool operator < (const Edge& W) const 
    {
        return c < W.c;
    }
}edges[M];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
// 深搜无向树，使用父节点，避免回头导致TLE
void dfs(int u, int fa, int maxd1, int maxd2, int d1[], int d2[])
{
    d1[u] = maxd1, d2[u] = maxd2;
    
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != fa)
        {
            // if (w[i] > maxd1) maxd2 = maxd1, maxd1 = w[i];
            // if (w[i] < maxd1 && w[i] > maxd2) maxd2 = w[i];
            // dfs(j, u, maxd1, maxd2, d1, d2);
            
            // 需要使用临时变量，上面注释的代码是错误的。一次到底是一条路径，当回溯的时候就是另           外一条路径，那么这个时候不能被上一条路径的权值影响。
            int td1 = maxd1, td2 = maxd2;  
            if (w[i] > td1) td2 = td1, td1 = w[i];
            if (w[i] < td1 && w[i] > td2) td2 = w[i];
            dfs(j, u, td1, td2, d1, d2);
        }
    }
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i++) p[i] = i;
    for (int i = 0; i < m; i++)
    {
        int a, b, c; cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }
    sort(edges, edges + m);
    
    LL sum = 0;
    for (int i = 0; i < m; i++)  // Kruscal
    {
        int a = edges[i].a, b = edges[i].b, c = edges[i].c;
        int pa = find(a), pb = find(b);
        if (pa != pb)
        {
            p[pa] = pb;
            sum += c;
            edges[i].f = true;  // 标记为树边
            add(a, b, c), add(b, a, c);  // 建立最小生成树
        }
    }
    // 枚举出最小生成树中任意两点路径上的最大边权和次大边权
    for (int i = 1; i <= n; i++) dfs(i, -1, -1e9, -1e9, dist1[i], dist2[i]);
    
    LL res = 1e18;
    for (int i = 0; i < m; i++)
    {
        if (!edges[i].f)
        {
            int a = edges[i].a, b = edges[i].b, c = edges[i].c;
            LL t = 0;
            if (c > dist1[a][b]) t = sum + c - dist1[a][b];
            else if (c > dist2[a][b]) t = sum + c - dist2[a][b];
            res = min(res, t);
        }
    }
    
    cout << res << "\n";
}