布线问题 最小生成树 prim + kruskal

1 : 第一种 prime     首先确定一个点 作为已经确定的集合 , 然后以这个点为中心 , 向没有被收录的点 , 找最短距离( 到已经确定的点 ) , 找一个已知长度的最小长度的 边 加到 sum里面 然后收录这个点 ,

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<limits.h>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<map>
#include<cctype>
using namespace std;                // prim  针对点 进行 最小生成树的 构造
int a[][],visited[],tem[],dis,minn,n,m,sum;
int main()     //      首先  以 1 为 根节点  ,  开始向周围寻找  找到一个  最小的边
{                   //  然后 将 该边的 另一个端点标记为  已访问  然后 将该边  的长度 加到sum 中
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        sum=;
        for(int i=;i<=n;i++)
        {
            tem[i]=INT_MAX;          //  除了已经确定 了的楼 , 剩余的楼 到 集合中确定的 距离都是最大
            for(int j=;j<=n;j++)
                a[i][j]=INT_MAX;    //    每两个楼之间的距离超大
        }
        memset(visited,,sizeof(visited));
        while(m--)
        {
            int b,c,d;
            scanf("%d%d%d",&b,&c,&d);
            a[b][c]=a[c][b]=d;
        }
        int n1=n-,b=;
        b=;  // 楼的编号 从1 开始
        visited[]=;  //  1号楼  已经确定
        while(n1--)   //  只需要确定  n-1  条边
        {
            minn=INT_MAX;
            for(int i=;i<=n;i++)
            {
                if(b!=i&&a[b][i]<tem[i]&&!visited[i])//  不是自己到自己
                {
                    tem[i]=a[b][i];
                }
            }
            int j;
            for(int i=;i<=n;i++)
            {
                if(minn>tem[i]&&!visited[i])
                {
                    minn=tem[i];
                    j=i;            //  找到和 已知集合相连的 最小的一条边
                }
            }
            visited[j]=;
            b=j;
            sum+=minn;
        }
        minn=INT_MAX;
        for(int i=;i<n;i++)
        {
            scanf("%d",&b);
            minn=minn<b?minn:b;   // 找到   拉电源 最小花费的 楼 所花费的金额 .
        }
        printf("%d\n",minn+sum);
    }
    return ;
}

2 : kruskal     用一个结构体储存信息 , 然后 根据边长来 排序 , 然后一条一条边的收录 如果 形成了环  就不收录这一条边 .

 #include<stdio.h>
 #include<string.h>
 #include<math.h>
 #include<iostream>
 #include<limits.h>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #include<stack>
 #include<string>
 #include<sstream>
 #include<map>
 #include<cctype>
 using namespace std;
 int father[],sum;
 struct node
 {
     int x,y,l;
 };
 bool cmp(node a,node b)
 {
     return a.l<b.l;
 }
 int find(int x)                      //  做了时间上的优化 ,但是 在空间复杂度上比较高
 {
     if(x!=father[x])
         father[x]=find(father[x]);
     sum++;
     return father[x];
 }
 bool merge(int x,int y)    // 做了时间复杂度上的优化  让并查集的 深度尽量  浅
 {
     int sum1,sum2;
     sum=;
     x=find(x);
     sum1=sum;        //    x  的深度
     sum=;
     y=find(y);
     sum2=sum;       //    y   的深度
     if(x!=y)
     {
         if(sum1>sum2)
             father[y]=x;
         else
             father[x]=y;
         return true;
     }
     else
         return false;
 }
 node a[];
 int main()
 {
     int t,n,m;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&m);
         sum=;
         for(int i=;i<m;i++)
         {
             int b,c,d;
             scanf("%d%d%d",&b,&c,&d);
             a[i].x=b;
             a[i].y=c;
             a[i].l=d;
         }
         sort(a,a+m,cmp);
         int count1=;
         for(int i=;i<=;i++)
             father[i]=i;
         int sum1=;
         for(int i=;i<m;i++)    //    开始 做了他
         {
             if(merge(a[i].x,a[i].y))   //     返回 flase 的话 就代表成环了
             {
                 count1++;
                 sum1+=a[i].l;
                 if(count1==n-)   //  如果已经形成 树的话
                     break;
             }
         }
         int minn=INT_MAX;
         for(int i=;i<n;i++)
         {
             int b;
             scanf("%d",&b);
             minn=b<minn?b:minn;
         }
         printf("%d\n",minn+sum1);
     }
     return ;
 }