FJUToj畅通工程1487(最小生成树)

畅通工程（2020.12.17更新）

 

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input

测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

Output

对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。

SampleInput

3 3
1 2 1
1 3 2
2 3 4
1 3
2 3 2
0 100

SampleOutput

3
?

kruskal(克鲁斯卡尔)算法
解析：目前只学了kruskal算法，所以只会用这种，其实所有的畅通工程都是一样的。像学长说的那样就是贪心+并查集，
没了就是这两种。先将每条路拿出来，然后根据每条路的权值进行排序，然后从大到小依次向外拿，并且需要进行查看
是否已被标记，若没有则可以将这条路算入节点中，直到把每条路遍历，最后得出的答案就是对的。（今天听了学长
讲课才懂了这个）

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int n,m,pre[105];
struct node//存放数据
{
    int x,y,data;
}s1[105];
void init()//先初始化，并查集的内容
{
    for(int i=1;i<=n;i++)
    {
        pre[i]=i;
    }
}
int fun(int x)//查找根节点，记住最好要压缩路径
{
    int r=x;
    while(r!=pre[r])
    {
        r=pre[r];
    }
    int i=x,j;
    while(i!=j)
    {
        j=pre[i];
        pre[i]=r;
        i=j;
    }
    return r;
}
bool cmp(const node &t1,const node &t2)//重载
{
    return t1.data<t2.data;
}
int main(void)
{
    while(scanf("%d%d",&n,&m)&&n)
    {
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&s1[i].x,&s1[i].y,&s1[i].data);
        }
        sort(s1+1,s1+n+1,cmp);//对数据惊进行排序
        int cont=m,sum=0,x,y;
        for(int i=1;i<=n;i++)
        {
            x=fun(s1[i].x);
            y=fun(s1[i].y);
            if(x!=y)
            {
                sum+=s1[i].data;
                cont--;
                pre[y]=x;
            }
        }
        if(cont==1)
            printf("%d\n",sum);
        else
            printf("?\n");
    }
}

Prim（普利姆）算法

解析：先随意选择一个顶点加到顶点集 U 里，然后其他顶点属于顶点集 V-U 里，在这两个顶点集之间选择一条最小的边，然后将 V-U 里连接的那个点加到 U 里，将这个点从 V-U里去除，这样就形成新的两个顶点集，并且更新完两个顶点集后还要更新两个顶点集之间的边（有可能刚开始V-U里某个点跟U没链接，更新完顶点集后就有边可以连接了）,然后就这样以此类推选出n-1条边，这些边相加就可以形成最小生成树（如果取最大点也可以这样，只是需要加一个标记数组）。代码里的lowcost数组是存V-U每个点顶点集到U的边长度，closest数组是V-U里的顶点与顶点集U所连接边的那另一个顶点。 

具体过程还是以图片看比较好好理解，理论的太繁琐了（数据结构书里的图搞过来的）。

附上代码：

#include <cstdio>
#include <queue>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <bitset>
#include <map>
#include <stack>
#include <stdlib.h>
#include <set>
#include <cstring>
#include <string>
#include <vector>
#define ll long long
#define pi acos(-1)
#define mod 1000000007
#define INF 0x3f3f3f3f
#define exp 1e-8
using namespace std;
int a[105][105];
int Prim(int n)
{
    int s=1,k,sum=0;
    int lowcost[105],minx,closest[105];
    for(int i=1;i<=n;i++)
    {
        lowcost[i]=a[s][i];//V-U里每个点与U的距离
        closest[i]=s;//V-U里每个点连接的是U里的哪个店，这个这里可以不用
    }
    lowcost[s]=0;//这个很重要，s已经在U里了，到自己的距离为0

    for(int i=2;i<=n;i++)//找n-1条边
    {
        minx=INF;
        k=-1;
        for(int j=1;j<=n;j++)//找最小边
        {
            if(lowcost[j]&&lowcost[j]<minx)
            {
                minx=lowcost[j];
                k=j;
            }
        }
        if(minx==INF)//没有边连接直接退出
            return -1;
        lowcost[k]=0;//这个点加到U里
        sum+=minx;//加上值
        for(int j=1;j<=n;j++)//更新V-U里每个点到U的边的长
        {
            if(lowcost[j]&&a[k][j]<lowcost[j])
            {
                lowcost[j]=a[k][j];
                closest[j]=k;
            }
        }
    }
    return sum;
}
int main(void)
{
    int n,x,y,w,m;
    while(scanf("%d%d",&m,&n))
    {
        if(!m)
            break;
        memset(a,INF,sizeof(a));//初始化每条边
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&w);
            a[x][y]=w;//有时候也要在这里加上判断是不是最短边
            a[y][x]=w;
        }
        int k=Prim(n);
        if(k!=-1)
            printf("%d\n",k);
        else
            printf("?\n");
    }
}