AcWing 1141. 局域网 (最小生成森林)

整理的算法模板：ACM算法模板总结（分类详细版）

某个局域网内有 nn 台计算机和 kk 条 双向 网线，计算机的编号是 1∼n1∼n。由于搭建局域网时工作人员的疏忽，现在局域网内的连接形成了回路，我们知道如果局域网形成回路那么数据将不停的在回路内传输，造成网络卡的现象。

注意：

• 对于某一个连接，虽然它是双向的，但我们不将其当做回路。本题中所描述的回路至少要包含两条不同的连接。
• 两台计算机之间最多只会存在一条连接。
• 不存在一条连接，它所连接的两端是同一台计算机。

因为连接计算机的网线本身不同，所以有一些连线不是很畅通，我们用 f(i,j)f(i,j) 表示 i,ji,j 之间连接的畅通程度，f(i,j)f(i,j) 值越小表示 i,ji,j 之间连接越通畅。

现在我们需要解决回路问题，我们将除去一些连线，使得网络中没有回路且不影响连通性（即如果之前某两个点是连通的，去完之后也必须是连通的），并且被除去网线的 Σf(i,j)Σf(i,j) 最大，请求出这个最大值。

输入格式

第一行两个正整数 n,kn,k。

接下来的 kk 行每行三个正整数 i,j,mi,j,m 表示 i,ji,j 两台计算机之间有网线联通，通畅程度为 mm。

输出格式

一个正整数，表示被除去网线的 Σf(i,j)Σf(i,j) 的最大值。

数据范围

1≤n≤1001≤n≤100
0≤k≤2000≤k≤200
1≤f(i,j)≤10001≤f(i,j)≤1000

输入样例：

5 5
1 2 8
1 3 1
1 5 3
2 4 5
3 4 2

输出样例：

8

难度：简单

时/空限制：1s / 64MB

总通过数：212

总尝试数：305

来源：《信息学奥赛一本通》

算法标签  最小生成树

类似于最小生成树的做法，prim算法和kruskal算法同样可以求最小生成森林；

直接套用模板即可；（用prim算法的时候，如果当前的点被选中后，到当前最小生成树的距离是正无穷，那说明，新产生了一个连通块，那么此时要用与这个点相连的所有点的信息来更新此连通块的最小生成树的值）

Prim：

#include <bits/stdc++.h>
using namespace std; 
const int N=105;
int n,k;    // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    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;
        st[t] = true;
        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
        if(i&&dist[t]==0x3f3f3f3f) continue;
        if (i) res += dist[t];
    }

    return res;
}
int main()
{
    memset(g,0x3f,sizeof g);
    cin >>n>>k;
    int ans=0;
    while(k--)
    {
        int a,b,c;
        cin >>a>>b>>c;
        g[a][b]=c,g[b][a]=c;
        ans+=c;
    }
    cout <<ans-prim()<<endl;;
}

kruskal：

#include <bits/stdc++.h>
using namespace std; 
const int N=205;
int n,k;
int p[N];
struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[N];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + k);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0;
    for (int i = 0; i < k; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
        }
    }
    return res;
}
int main()
{
    cin >>n>>k;
    int ans=0;
    for(int i=0;i<k;i++)
    {
        cin >>edges[i].a>>edges[i].b>>edges[i].w;
        ans+=edges[i].w;
    }
    cout <<ans-kruskal()<<endl;;
}