HDU1102--最小生成树

Constructing Roads

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 9149    Accepted Submission(s): 3383

Problem Description

There are N villages, which are numbered from 1 to N, and you should build some roads such that every two villages can connect to each other. We say two village A and B are connected, if and only if there is a road between A and B, or there exists a village C such that there is a road between A and C, and C and B are connected.
We
know that there are already some roads between some villages and your
job is the build some roads such that all the villages are connect and
the length of all the roads built is minimum.

 

Input

The first line is an integer N (3 <= N
<= 100), which is the number of villages. Then come N lines, the
i-th of which contains N integers, and the j-th of these N integers is
the distance (the distance should be an integer within [1, 1000])
between village i and village j.
Then there is an integer Q (0 <=
Q <= N * (N + 1) / 2). Then come Q lines, each line contains two
integers a and b (1 <= a < b <= N), which means the road
between village a and village b has been built.

 

Output

You should output a line contains an integer,
which is the length of all the roads to be built such that all the
villages are connected, and this value is minimum.

 

Sample Input

3

0 990 692

990 0 179

692 179 0

1

1 2

 

Sample Output

179

 

Source

kicc

 

Recommend

Eddy

 

Prim算法

1.概览

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。

2.算法简单描述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：V_new = {x}，其中x为集合V中的任一节点（起始点），E_new = {},为空；

3).重复下列操作，直到V_new = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合V_new中的元素，而v不在V_new集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合V_new中，将<u, v>边加入集合E_new中；

4).输出：使用集合V_new和E_new来描述所得到的最小生成树。

下面对算法的图例描述

图例	说明	不可选	可选	已选（Vnew）
	此为原始的加权连通图。每条边一侧的数字代表其权值。	-	-	-
	顶点D被任意选为起始点。顶点A、B、E和F通过单条边与D相连。A是距离D最近的顶点，因此将A及对应边AD以高亮表示。	C, G	A, B, E, F	D
	下一个顶点为距离D或A最近的顶点。B距D为9，距A为7，E为15，F为6。因此，F距D或A最近，因此将顶点F与相应边DF以高亮表示。	C, G	B, E, F	A, D
	算法继续重复上面的步骤。距离A为7的顶点B被高亮表示。	C	B, E, G	A, D, F
	在当前情况下，可以在C、E与G间进行选择。C距B为8，E距B为7，G距F为11。E最近，因此将顶点E与相应边BE高亮表示。	无	C, E, G	A, D, F, B
	这里，可供选择的顶点只有C和G。C距E为5，G距E为9，故选取C，并与边EC一同高亮表示。	无	C, G	A, D, F, B, E
	顶点G是唯一剩下的顶点，它距F为11，距E为9，E最近，故高亮表示G及相应边EG。	无	G	A, D, F, B, E, C
	现在，所有顶点均已被选取，图中绿色部分即为连通图的最小生成树。在此例中，最小生成树的权值之和为39。	无	无	A, D, F, B, E, C, G

3.简单证明prim算法

反证法：假设prim生成的不是最小生成树

1).设prim生成的树为G₀

2).假设存在G_min使得cost(G_min)<cost(G₀)   则在G_min中存在<u,v>不属于G₀

3).将<u,v>加入G₀中可得一个环，且<u,v>不是该环的最长边(这是因为<u,v>∈G_min)

4).这与prim每次生成最短边矛盾

5).故假设不成立，命题得证.

4.PRIM代码

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 using namespace std;

 const int INF=;
 const int MAXN=;

 int n,m;
 int map[MAXN][MAXN];
 int dis[MAXN];
 int visit[MAXN];

 int prim()
 {
     for(int i=; i<=n; i++)
         dis[i]=INF;

     dis[]=;              //起点为顶点1
     for(int j=; j<=n; j++)
     {
         int t=INF,pos;  //临时变量:最短路径距离t,和该顶点pos
         for(int i=; i<=n; i++)   //查找最短路径'点'
         {
             if(!visit[i]&&t>dis[i])
             {
                 t=dis[i];
                 pos=i;
             }
         }
         visit[pos]=;         //最短路径点标记为已经访问
         for(int i=; i<=n; i++) //更新最短路径点
         {
             //如果,顶点i未被访问过
             //且图中新加入的pos点到i点的距离短于原来图到i点的距离
             //且pos到i的点有连通(即不为无穷大),则将i点到图的距离更新.
             if(!visit[i]&&dis[i]>map[pos][i]&&map[pos][i]!=INF)
             {
                 dis[i]=map[pos][i];
             }
         }
     }
     int temp=;
     for(int k=; k<=n; k++)
     {
         temp+=dis[k];
     }
     return temp;
 }

 int main()
 {
     int a,b;
     while(cin>>n)
     {
         memset(map,0x3f,sizeof(map));
         memset(visit,,sizeof(visit));
         for(int i=; i<=n; i++)
         {
             for(int j=; j<=n; j++)
             {
                 cin>>map[i][j];
             }
         }
         cin>>m;
         while(m--)
         {
             cin>>a>>b;
             map[a][b]=;
             map[b][a]=;
         }
         int ans=prim();
         cout<<ans<<endl;
     }
     return ;
 }

Kruskal算法

1.概览

Kruskal算法是一种用来寻找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪婪算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。

2.算法简单描述

1).记Graph中有v个顶点，e个边

2).新建图Graph_new，Graph_new中拥有原图中相同的e个顶点，但没有边

3).将原图Graph中所有e个边按权值从小到大排序

4).循环：从权值最小的边开始遍历每条边 直至图Graph中所有的节点都在同一个连通分量中

if 这条边连接的两个节点于图Graph_new中不在同一个连通分量中

添加这条边到图Graph_new中

图例描述：

首先第一步，我们有一张图Graph，有若干点和边

将所有的边的长度排序，用排序的结果作为我们选择边的依据。这里再次体现了贪心算法的思想。资源排序，对局部最优的资源进行选择，排序完成后，我们率先选择了边AD。这样我们的图就变成了右图

在剩下的变中寻找。我们找到了CE。这里边的权重也是5

依次类推我们找到了6,7,7，即DF，AB，BE。

下面继续选择， BC或者EF尽管现在长度为8的边是最小的未选择的边。但是现在他们已经连通了（对于BC可以通过CE,EB来连接，类似的EF可以通过EB,BA,AD,DF来接连）。所以不需要选择他们。类似的BD也已经连通了（这里上图的连通线用红色表示了）。

最后就剩下EG和FG了。当然我们选择了EG。最后成功的图就是右：

3.简单证明Kruskal算法

对图的顶点数n做归纳，证明Kruskal算法对任意n阶图适用。

归纳基础：

n=1，显然能够找到最小生成树。

归纳过程：

假设Kruskal算法对n≤k阶图适用，那么，在k+1阶图G中，我们把最短边的两个端点a和b做一个合并操作，即把u与v合为一个点v'，把原 来接在u和v的边都接到v'上去，这样就能够得到一个k阶图G'(u,v的合并是k+1少一条边)，G'最小生成树T'可以用Kruskal算法得到。

我们证明T'+{<u,v>}是G的最小生成树。

用反证法，如果T'+{<u,v>}不是最小生成树，最小生成树是T，即W(T)<W(T'+{<u,v>})。显然T应该包含<u,v>，否则，可以用<u,v>加入到T中，形成一个环，删除环上原有的任意一条边，形成一棵更小权值的生成树。而T-{<u,v>}，是G'的生成树。所以W(T-{<u,v>})<=W(T')，也就是W(T)<=W(T')+W(<u,v>)=W(T'+{<u,v>})，产生了矛盾。于是假设不成立，T'+{<u,v>}是G的最小生成树，Kruskal算法对k+1阶图也适用。

由数学归纳法，Kruskal算法得证。

4.Kruskal代码

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 int  fa[];
 int n,m;
 int cc;
 struct edge
 {
     int u,v,w;
     void  set(int x,int y,int s)
     {
         u=x;
         v=y;
         w=s;
     }

 }e[];
 int  find(int x)
 {
     return x==fa[x]?x:fa[x]=find(fa[x]);
 }
 bool  cmp(edge a,edge b)
 {
     return a.w<b.w;
 }
 void   kruskal()
 {
     int  ans=;cc=n;
     sort(e,e+n*n,cmp);
     for(int i=; i<n*n; i++)
     {
         int x=find(e[i].u);
         int y=find(e[i].v);
         if(x!=y)
         {
             fa[x]=y;
             ans+=e[i].w;
             cc--;
         }
     }
     if(cc==)
     printf("%d\n",ans);
 }

 void   init()
 {
     for(int i=; i<n; i++)
         fa[i]=i;

 }
 int main()
 {
     while(cin>>n)
     {
         init();
         int cnt=;int d[][];
         for(int i=; i<n; i++)
             for(int j=; j<n; j++)
                 scanf("%d",&d[i][j]);
         int Q;
         cin>>Q;
         int a,b;
         for(int i=; i<Q; i++)
         {
             scanf("%d%d",&a,&b);
             d[a-][b-]=;
         }
         for(int i=; i<n; i++)
             for(int j=; j<n; j++)
             {

                 e[cnt].set(i,j,d[i][j]);

                 cnt++;
             }
         kruskal();

     }
     return ;
 }

本小白觉得的 这个 跟 最短路有些像呢