Prim算法

Prim算法是用来求带权无向图中的最小生成树。

我对其解释如下：

1.对于带权无向图G=（V，E）。有一集合s，开始时从图中任选一点origin并入s中，origin即为起点。

2.选取一条弧<j,k>,顶点j属于s中，顶点k属于V-s中，并且<j,k>的权值为可选的边中的最小的。

3.将顶点k并入s中。

4.重复2-3，直到s包含了所有顶点（或已经执行了n-1次）

在算法中，主要是使用了两个for循环，一个寻找s中顶点，一个寻找V-s中顶点，因此时间复杂度为n^2;

代码如下：

#include <iostream>
#define MAX 999999
using namespace std;
const int n=7;
int map[n+1][n+1];        //邻接矩阵
int s[n+1] = {0};         //集合S
int lowestCost[n+1]={0};  //起始点到节点i的权重值
int pre[n+1]={0};         // 节点i的直接前驱为pre[i]

void findPath(int i)      //输出路径
{
    if(pre[i] == 0)
    {
        cout<<i;
        return ;
    }
    findPath(pre[i]);
    cout<<"-"<<i;
}
int main()
{
    int i,j,weight;
    int origin;             //起点
    int totalCost=0;        //总花费
    for(i=1;i<=n;i++)       //初始化邻接矩阵
        for(j=1;j<=n;j++)
            map[i][j]=MAX;

    cout<<"输入各节点权重值: "<<endl;
    while(1)
    {
        cin>>i>>j>>weight;
        if(i==0 && j==0 && weight==0)
            break;
        map[i][j]=weight;
        map[j][i]=weight;
    }
    cout<<"输入起始节点: ";
    cin>>origin;
    s[origin] = 1;          //将起点并入s中
    int count = 0;          //操作次数，操作n-1次即停止
    while(1)
    {
        int minWeight=MAX;
        int minPoint=0;
        int preNode=0;
        for(i=1;i<=n;i++)       //寻找V-s中顶点
        {
            for(j=1;j<=n;j++)   //寻找s中顶点
            {
                if(!s[i] && s[j] && map[j][i]<minWeight)        // i : V-s中的顶点，j : s中顶点
                {
                    minWeight = map[j][i];
                    minPoint = i;
                    preNode = j;
                }
            }
        }
        totalCost += minWeight;
        s[minPoint] = 1;        //将找到的顶点并入s中
        lowestCost[minPoint] = lowestCost[preNode] + minWeight;
        pre[minPoint] = preNode;
        count++;
        if(count==n-1)
            break;
    }

    for(i=1;i<=n;i++)
    {
        cout<<"起点到顶点"<<i<<"的路线为: ";
        findPath(i);
        cout<<endl;
        cout<<"花费为: "<<lowestCost[i]<<endl;;
    }
    cout<<"总花费为: "<<totalCost<<endl;
    return 0;
}