最小生成树之Prim算法--蓝白点思想

Prim算法：　　　　

以前一直不是很明白，Prim算法，今天就来终结一下。

Prim算法采用与Dijkstra、Bellman-Ford算法一样的“蓝白点”思想：白点代表已经进入最小生成树的点，蓝点代表未进入最小生成树的点。

算法描述：

以1为起点生成最小生成树，min[v]表示蓝点v与白点相连的最小边权。

MST表示最小生成树的权值之和。

a）初始化：min[v]= ∞(v≠1); min[1]=0;MST=0;

b）for (i = 1; i<= n; i++)

1.寻找min[u]最小的蓝点u。

2.将u标记为白点

3.MST+=min[u]

4.for 与白点u相连的所有蓝点v 

                 if (w[u][v]<min[v])

                      min[v]=w[u][v];

c）算法结束： MST即为最小生成树的权值之和

 

算法分析&思想讲解：

    Prim算法每次循环都将一个蓝点u变为白点，并且此蓝点u与白点相连的最小边权min[u]还是当前所有蓝点中最小的。这样相当于向生成树中添加了n-1次最小的边，最后得到的一定是最小生成树。

例题：（cojs）602. 新的开始

★★   输入文件：newstart.in   输出文件：newstart.out   简单对比
时间限制：1 s   内存限制：128 MB

【题目描述】

发展采矿业当然首先得有矿井，  小  FF  花了上次探险获得的千分之一的财富请人在岛

上挖了 n 口矿井，  但他似乎忘记考虑的矿井供电问题……

为了保证电力的供应，  小 FF 想到了两种办法：

1、  在这一口矿井上建立一个发电站，  费用为  v（发电站的输出功率可以供给任

意多个矿井）。

2、  将这口矿井与另外的已经有电力供应的矿井之间建立电网，  费用为 p。

小 FF 希望身为”NewBe_One"  计划首席工程师的你帮他想出一个保证所有矿井电力供

应的最小花费。

【输入格式】

第一行一个整数 n，  表示矿井总数。

第 2～n+1 行，每行一个整数，  第 i 个数 v[i]表示在第 i 口矿井上建立发电站的费用。

接下来为一个 n*n 的矩阵 P，  其中 p[ i , j ]表示在第 i 口矿井和第 j 口矿井之间建立

电网的费用（数据保证有 p[ i, j ] = p[ j, i ],  且  p[ i, i ]=0）。

【输出格式】

仅一个整数，  表示让所有矿井获得充足电能的最小花费。

【输入样例】

4

5

4

4

3

0 2 2 2

2 0 3 3

2 3 0 4

2 3 4 0

【输出样例】

9

输出样例说明：

小 FF 可以选择在4号矿井建立发电站然后把所有矿井都与其建立电网，总花费是

3+2+2+2 = 9。

【数据范围】

对于30%的数据：      1<=n<=50;

对于100%的数据：    1<=n<=300;      0<=v[i], p[i,j] <=10^5.

/*先加点，再跑最小生成树*/
#include<iostream>
using namespace std;
#include<cstdio>
#include<cstring>
#define INF (1<<31)-1
#define N 621
int n;
struct Edge{
    int v,w,last;
};
Edge edge[N*N];
int t=;
int head[N],miu[N];
bool flag[N];
long long int mst=;
void input()
{
    scanf("%d",&n);
    int a;
    for(int i=;i<=n;++i)
    {
        scanf("%d",&a);
        ++t;
        edge[t].v=i;
        edge[t].w=a;
        edge[t].last=head[n+];
        head[n+]=t;
        ++t;
        edge[t].v=n+;
        edge[t].w=a;
        edge[t].last=head[i];
        head[i]=t;
    }
    for(int i=;i<=n;++i)
      for(int j=;j<=n;++j)
      {
          scanf("%d",&a);
          ++t;
          edge[t].v=j;
          edge[t].w=a;
          edge[t].last=head[i];
          head[i]=t;
      }
    n+=;
}
void Prim()
{
    mst=;
    memset(miu,,sizeof(miu));
    miu[n]=;/*从第n个点开始建树*/
    memset(flag,false,sizeof(flag));
    int p,maxx=INF;
    for(int i=;i<=n;++i)
    {
        maxx=INF;
        for(int j=;j<=n;++j)
        {/*!flag[j]，找出miu最小的蓝点p*/
            if(!flag[j]&&miu[j]<maxx)
            {
                maxx=miu[j];
                p=j;
            }
        }
        flag[p]=true;/*标记*/
        mst+=miu[p];/*把p加入树内*/
        for(int l=head[p];l;l=edge[l].last)
        {
            int vi=edge[l].v;
            if(!flag[vi]&&edge[l].w<miu[vi])
            miu[vi]=edge[l].w;/*miu储存着蓝点vi到白点的最小距离*/
        }
    }
}
int main()
{
    freopen("newstart.in","r",stdin);
    freopen("newstart.out","w",stdout);
    input();
    Prim();
    cout<<mst<<endl;
    fclose(stdin);
    fclose(stdout);
    return ;
}

Prim算法