7-50 畅通工程之局部最小花费问题 (35 分)

kruskal算法，选边法

重点：利用并查集记录、判断连通分量

/**
* Copyright(c)
* All rights reserved.
* Author : Sweeney He
* Date : 2021-02-05-11.33.17
* Description : 算法
*/
#include <iostream>
#include <stdlib.h>
#include <cstring>
#include<algorithm>
#define maxsize 101

using namespace std;

//kruskal算法用边表
typedef struct EDGE
{
    int s;//起点
    int e;//终点
    int weight;//边上权重
} eg,*Eg;

//sort用结构体排序规则,按照权重从小到大排序
bool cmp(eg a,eg b)
{
    return a.weight<b.weight;
}

//并查集，查找队长
int finds(int*parent,int e)
{
    int x = e;
    while(parent[x]!=x)
        x = parent[x];
    return x;
}


//kruskal算法求最小生成树最短路径
int solveKruskal(Eg edge,int n)
{
    //并查集记录连通分量
    int parent[n+1];
    //并查集赋初值
    for(int i = 1; i<n+1 ; i++)
        parent[i] = i;
    
    int a,b,z = 0;
    //记录总和
    int sum = 0;
    //按边排序
    sort(edge,edge+(n*(n-1))/2,cmp);
    //开始选边
    for(int i = 0 ; i<n*(n-1)/2 ; i++)
    {
        //起点与终点不在同一个连通分量中则加入
        a = finds(parent,edge[i].s);
        b = finds(parent,edge[i].e);
        //不在同一连通分量
        if(a!=b)
        {
            z++;
            //加入同一连通分量
            parent[a] = b;
            sum+=edge[i].weight;
        }
        //选中n-1条边则结束
        if(z==n-1)
            return sum;
    }
    //写着规范，如果不出错则不会运行到这里
    return sum;
}


int main()
{
    int n,f;
    cin>>n;
    eg edge[n*(n-1)/2];

    for(int i = 0 ; i<n*(n-1)/2 ; i++)
    {
        cin>>edge[i].s>>edge[i].e>>edge[i].weight>>f;
        //如果已经建立好边则权重标识为0(尽可能利用已有的边)
        if(f==1)
            edge[i].weight = 0;
    }
    cout<<solveKruskal(edge,n);
    return 0;
}

 prime算法

lowcost [ i ] 记录的是树(树中所有结点)距离i号结点的最小值

#include <iostream>
#include <stdlib.h>
#include <cstring>
#define maxsize 101
using namespace std;

const int INF = 1<<30;


//prime算法求最小生成树
int solvePrime(int graph[][maxsize],int n,int s)
{
    //记录结点是否访问
    int visited[n+1];
    memset(visited,0,sizeof(int)*(n+1));
    //起点设置为已访问
    visited[s] = 1;
    //记录树中结点与各个结点的最小距离
    int lowcost[n+1];
    //赋初值
    for(int i = 1 ; i<n+1 ; i++)
        lowcost[i] = graph[s][i];

    int lowest,k;
    int sum = 0;
    //循环n-1次
    for(int z = 1 ; z<n ; z++)
    {
        lowest = INF;
        //查找不在树中据树最近的结点
        for(int i = 1 ; i<n+1 ; i++)
            if(!visited[i]&&lowcost[i]<lowest){
                lowest = lowcost[i];
                k = i;
            }
        //将结点加入到树中
        visited[k] = 1;
        sum+=lowest;
        //用新加入的结点k维护lowcost[]
        for(int j = 1 ;j<n+1 ;j++){
            //(k,j)<(k',j)则更新,
            //k'表示上次新加入的结点,k表示本次新加入的结点
            if(graph[k][j]<lowcost[j]&&j!=k)
                lowcost[j] = graph[k][j];
        }
    }
    return sum;
}




int main()
{
    int n,s,e,w,f;
    int graph[maxsize][maxsize];
    cin>>n;
    for(int i = 0 ; i<n*(n-1)/2 ; i++)
    {
        cin>>s>>e>>w>>f;
        //如果已经建立好边则权重标识为0(尽可能利用已有的边)
        if(f==1)
            w = 0;
        graph[e][s] = graph[s][e] = w;
    }
    cout<<solvePrime(graph,n,1);

    return 0;
}