次小生成树个人理解 prime和kruskal两种算法+PTA例题

看网上关于次小生成树的时候一直有点不理解max[i][j]数组的用处，直到自己通过画图才得以理解。

首先讲讲如何求次小生成树，也就是最小生成树之外的最优解。大概的方法就是从未使用的边中（没有被最小生成树包括的边）选一条加入最小生成树，那么肯定会形成一个环了，然后从环中减去最大的一条边即可。而这时候max数组的作用就体现出来了，max[i][j]保存的是从i到j的路径中最长的那一小段路径长度，那么在构成环的时候减去环中除了新边外最大的一条边的时候就很方便了。然后只要遍历所有未使用的边，重复以上步骤，找到最小的结果就是次小生成树的权值和了。

既然max数组是保存从i到j的路径中最长的那一小段路径长度，那么在建立最小生成树的时候就要对max进行更新。
在次小生成树上prime和kruskal算法均可实现，不同点在于对max数组更新的方法。

这里以pta上的一道题为例，采用两种算法解决。
不同算法更新max数组的方式在注释中有所解释。

kruskal算法

//kruskal算法
#include <bits/stdc++.h>
#define mem(a) memset(a, 0, sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;
inline void scf(int &a, int &b) { scanf("%d%d", &a, &b); }
inline void scf(int &a, int &b, int &c) { scanf("%d%d%d", &a, &b, &c); }
struct edge
{
    int x;
    int y;
    int val;
} e[250000];//表示边
int n, m, fa[505], maxedge[505][505], used[250000];//这里的maxedge就是上面所说的max数组
inline int find(int x)
{
    if (fa[x] == x)
        return x;
    return fa[x] = find(fa[x]);
}
bool cmp(edge a, edge b)
{
    return a.val < b.val;
}
void kruskal()
{
    //初始化工作
    int tmp = 0, cnt = 0;
    vector<int> v[501]; //用来保存一个集合的点，在更新maxedge数组时会用到，下标就是fa数组中对应的值
    for (int i = 1; i <= n; i++) 
    {
        v[i].push_back(i);
        fa[i] = i;
    }
    mem(used);
    mem(maxedge);

    //生成最小树
    for (int i = 0; i < m; i++) 
    {
        if (cnt == n - 1) break;
        int a = e[i].x, b = e[i].y, c = e[i].val;
        int f1 = find(a), f2 = find(b);
        if (f1 != f2)
        {
            tmp += c;
            cnt++;
            used[i] = 1;
            //更新maxedge数组，从一个集合的点到另一个集合的点的路径全部都要更新
            for (int j = 0; j < v[f1].size(); j++)
            {
                int v1 = v[f1][j],v2;
                for (int k = 0; k < v[f2].size(); k++)
                {
                    v2 = v[f2][k];
                    //由于kruskal算法的特性，边已经按升序排列好了，
                    //越到后面边的权值会越大，所以可以保证maxedge不会大于当前边的权值，因此直接赋值即可
                    maxedge[v1][v2] = maxedge[v2][v1] = c;
                }
            }
            //合并两个点集
            if (v[f1].size() > v[f2].size()) //f1的集合更大，将f2归并到f1中
            {
                fa[f2] = f1;
                for (int j = 0; j < v[f2].size(); j++)
                {
                    v[f1].push_back(v[f2][j]);
                }
                v[f2].clear();
            }
            else //f2的集合大
            {
                fa[f1] = f2;
                for (int j = 0; j < v[f1].size(); j++)
                {
                    v[f2].push_back(v[f1][j]);
                }
                v[f1].clear();
            }
        }
    }
    
    if (cnt != n - 1)//无法生成最小树
    {
        printf("No MST\n%d", n - cnt);
        return;
    }

    int res = inf;
    for (int i = 0; i < m; i++) //寻找次小生成树
    {
        if (!used[i])
        {
            int a = e[i].x, b = e[i].y, c = e[i].val;
            res = min(res, tmp + c - maxedge[a][b]);
        }
    }
    if (res != tmp)
    {
        printf("%d\nYes", tmp);
    }
    else
    {
        printf("%d\nNo", tmp);
    }
}

int main()
{
    int x, y, v;
    scf(n, m);
    for (int i = 0; i < m; i++)
    {
        scf(x, y, v);
        e[i] = {x, y, v};
    }
    sort(e, e + m, cmp);
    kruskal();
    return 0;
}

prime算法

//prime算法
#include <bits/stdc++.h>
#define mem(a) memset(a, 0, sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;
inline void scf(int &a, int &b) { scanf("%d%d", &a, &b); }
inline void scf(int &a, int &b, int &c) { scanf("%d%d%d", &a, &b, &c); }
int n, m, maxedge[505][505], used[505][505], g[505][505], vis[505], sum = 0;

int prime()
{
    int root=1;
    //找到一个未成树的点作为起点
    while(vis[root] && root<=n) root++;
    if(root>n) return 0;

    vector<int> done,rest;//done保存已经加入树的点，rest保存剩下的点
    done.push_back(root);
    vis[root]=1;
    for(int i=1;i<=n;i++)
    {
        if(!vis[i]) rest.push_back(i);
    }

    int mval,pre,now;//now表示新加入的点，pre表示与新的点相连的那个点
    while(rest.size())
    {
        mval=inf;
        for(int i=0;i<done.size();i++)
        {
            int x=done[i],y;
            for(int j=0;j<rest.size();j++)
            {
                y=rest[j];
                if(g[x][y] &&g[x][y]<mval)
                {
                    pre=x;
                    now=y;
                    mval=g[x][y];
                }
            }
        }
        if(mval==inf) break;

        vis[now]=1;
        used[pre][now]=used[now][pre]=1;//used[x][y]=1表示点x与点y之间已经有一条边相连了
        sum+=mval;

        //更新maxedge数组
        for(int i=0;i<done.size();i++)
        {
            //因为prime算法新加入的点一定是和原来的树是连通的，树上所有的点都可以到达新点
            //maxedge[done[i]][pre]已经保存了从done[i]到pre的最长边，那么将其与新的边比较取大的即可
            maxedge[now][done[i]]=maxedge[done[i]][now]=max(maxedge[done[i]][pre],mval);
        }

        done.push_back(now);
        rest.erase(lower_bound(rest.begin(),rest.end(),now));
    }
    return 1;
}

int main()
{
    mem(used), mem(maxedge), mem(g), mem(vis);
    int x, y, val, cnt = 0;
    scf(n, m);
    for (int i = 0; i < m; i++)
    {
        scf(x, y, val);
        g[x][y] = g[y][x] = val;
    }
    while (prime()) cnt++;//用来找连通集的个数

    if (cnt == 1)//只有一个集合，即能建立最小生成树
    {
        int tmp = inf;
        //找次小生成树
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (!used[i][j] && g[i][j])//在树中两点之间没有成边且连通
                {
                    tmp = min(tmp, sum + g[i][j] - maxedge[i][j]);
                }
            }
        }
        if (tmp == sum)
        {
            printf("%d\nNo", sum);
        }
        else
        {
            printf("%d\nYes", sum);
        }
    }
    else
    {
        printf("No MST\n%d", cnt);
    }
    return 0;
}