hdu1233 Prime算法和 Kruskal算法

普利姆（Prime）算法（只与顶点相关）

 

算法描述：

普利姆算法求最小生成树时候，和边数无关，只和定点的数量相关，所以适合求稠密网的最小生成树，时间复杂度为O（n*n）。

算法过程：

1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。

2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个（设为v），将此顶点从B中删除，加入集合A中。

3.递归重复步骤2，直到B集合中的结点为空，结束此过程。

4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。

算法实现具体过程：

1.将第一个点放入最小生成树的集合中（标记visit[i]=1意思就是最小生成树集合）。

2.从第二个点开始，初始化lowcost[i]为跟1点相连（仅仅相连）的边的权值（lowcost[i]不是这个点的最小权值！在以后会逐步更新）。

3.找最小权值的边。

从第二点开始遍历，如果不是最小生成树的集合的点，则找出从2到n的最小权值（lowcost[j]）。

4.将找出来的最小权值的边的顶点加入最小生成树的集合中（标记visit[i] = 1），权值想加。

5.更新lowcost[j]集合。

假设第一次：lowcost[2]代表与1相连的点的权值，现在加入了k点。则比较k点与2点的边map[k][2]和lowcost[2]的大小，若lowcost[2]大，则lowcost[2] = map[k][2]。（关键步骤：实质就是每在最小生成树集合中加入一个点就需要把这个点与集合外的点比较，不断的寻找两个集合之间最小的边）

6.循环上述步骤，指导将全部顶点加入到最小生成树集合为止。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f//无穷大
#define MAX 1000
int map[MAX][MAX], lowcost[MAX];
bool visit[MAX];
int nodenum, sum;
void prim()
{
    int temp, k;
    sum = 0;
    memset(visit, false, sizeof(visit)); //初始化visit
    visit[1] = true;
    for(int i = 1; i <= nodenum; ++i) //初始化lowcost[i]
        lowcost[i] = map[1][i];
    for(int i = 1; i <= nodenum; ++i)//找生成树集合点集相连最小权值的边
    {
        temp = INF;
        for(int j = 1; j <= nodenum; ++j)
            if(!visit[j] && temp > lowcost[j])
                temp = lowcost[k = j];
        if(temp == INF) break;
        visit[k] = true; //加入最小生成树集合
        sum += temp;//记录权值之和
        for(int j = 1; j <= nodenum; ++j) //更新lowcost数组
            if(!visit[j] && lowcost[j] > map[k][j])
                lowcost[j] = map[k][j];
    }
}


int main()
{
    int a, b, cost, edgenum;
    while(scanf("%d", &nodenum),nodenum)
    {
        memset(map, INF, sizeof(map));
        edgenum = nodenum * (nodenum - 1) / 2;
        for(int i = 1; i <= edgenum; ++i) //输入边的信息
        {
            scanf("%d%d%d", &a, &b, &cost);
            if(cost < map[a][b])
                map[a][b] = map[b][a] = cost;
        }
        prim();
        printf("%d\n", sum); //最小生成树权值之和
    }
    return 0;
}

克鲁斯卡尔（Kruskal）算法（只与边相关）

算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（eloge）。

算法过程：

1.将图各边按照权值进行排序

2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。

3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。

克鲁斯卡尔（Kruskal）算法因为只与边相关，则适合求稀疏图的最小生成树。而prime算法因为只与顶点有关，所以适合求稠密图的最小生成树。

#include<iostream>
#include<string.h>
#include<string>
#include<stdio.h>
#include<algorithm>
using namespace std;
#define MAX 5000
int father[MAX],rank1[MAX];
int edgenum;//总的边数
struct Kruskal //存储边的信息
{
    int a;
    int b;
    int value;
};
Kruskal edge[MAX];
bool cmp( Kruskal o1,Kruskal o2)
{
    return o1.value < o2.value;
}
int find_set(int x)//查找x元素所在的集合,回溯时压缩路径
{
    if(x!=father[x])
        father[x]=find_set(father[x]);
    return father[x];
}
//bool为希尔型，结果要么对，要么错
bool union_set(int x,int y)//合并
{
    x=find_set(x);
    y=find_set(y);
    if(x==y) return false;//判断是否为环
    else if(rank1[x]>rank1[y])
    {
        father[y]=x;
    }
    else
    {
        if(rank1[x]==rank1[y])
            rank1[y]++;
        father[x]=y;
    }
    return true;
}
int main()
{
    int v,edgesum,sum;//顶点数，最小生成树的边数，路径之和

    while(scanf("%d",&v),v)
    {
        edgesum=0,sum=0;
        for(int i=1; i<=v; ++i) //初始化
        {
            father[i]=i;
            rank1[i]=0;
        }
        edgenum=v*(v-1)/2;
        for(int i = 1; i <= edgenum; ++i)
        {
            scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].value);
        }
        sort(edge + 1, edge + 1 + edgenum,cmp); //按权值由小到大排序
        for(int i = 1; i <=edgenum; ++i)
        {
            if(union_set(edge[i].a, edge[i].b))
            {
                edgesum++; //边数加1
                sum += edge[i].value; //记录权值之和
            }
            if(edgesum == v - 1) //最小生成树条件：边数=顶点数-1
            {
                break;
            }
        }
        printf("%d\n", sum);
    }
    return 0;
}