最小生成树（prime算法、kruskal算法） 和 最短路径算法（floyd、dijkstra）

转自：http://www.cnblogs.com/aiyelinglong/archive/2012/03/26/2418707.html

带权图分为有向和无向，无向图的最短路径又叫做最小生成树，有prime算法和kruskal算法；有向图的最短路径算法有dijkstra算法和floyd算法。

生成树的概念：联通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树 生成树是联通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则 将出现一个回路；若去掉一条边，将会使之编程非连通图。生成树各边的权 值总和称为生成素的权。权最小的生成树称为最小生成树，常用的算法有prime算法和kruskal算法。

最短路径问题旨在寻找图中两节点之间的最短路径，常用的算法有：floyd算法和dijkstra算法。

构造最小生成树一般使用贪心策略，有prime算法和kruskal算法

prime算法（适合稠密图）的基本思想

1.清空生成树，任取一个顶点加入生成树

2.在那些一个端点在生成树里，另一个端点不在生成树里的边中，选取一条权最小的边，将它和另一个端点加进生成树

3.重复步骤2，直到所有的顶点都进入了生成树为止，此时的生成树就是最小生成树

int prime(int cur)
{
int index;
int sum=0;
memset(visit,false,sizeof(visit));
visit[cur]=true;
for(int i=0;i<m;i++)
dist[i]=graph[cur][i];
for(int i=1;i<m;i++)
{
int mincost=INF;
for(int j=0;j<m;j++)
{
if(!visit[j] && mincost>dist[j])
{
mincost=dist[j];
index=j;
}
}
visit[index]=true;
sum+=mincost;
for(int j=0;j<m;j ++)
{
if(!visit[j] && dist[j]>graph[index][j])
dist[j]=graph[index][j];
}
}
return sum;
}

kruskal算法（适合稀疏图）：1、基本思想：设无向连通网为G＝(V, E)，令G的最小生成树为T＝(U, TE)，其初态为U＝V，TE＝{ }，然后，按照边的权值由小到大的顺序，考察G的边集E中的各条边。若被考察的边的两个顶点属于T的两个不同的连通分量，则将此边作为最小生成树的边加入到T中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T中的连通分量个数为1时，此连通分量便为G的一棵最小生成树。 

2、示例：



假设第 i条边的起点保存在数组u[i]中，终点保存在数组v[i]中，边权保存在w[i]中，而排序后第i小的边存放在r[i]中（此方法称为间接排序——排序的关键字是对象的代号，而非对象本身）

#include<iostream>
#include<algorithm>
using namespace std;

int cmp(const int i,const int j){return w[i]<w[j];}//间接排序函数

int find(int x){return p[x]==x?x:p[x]=find(p[x]);}//带路径压缩的并查集查找
//即：若p[x]==x,则x是树根，返回x，否则返回x的父亲p[x]所在树的根，并把x的根设置为其父所在树的根

int Kruskal()
{
int ans=0;
for(int i=0;i<n;i++)p[i]=i;//初始化并查集
for(int i=0;i<m;i++)r[i]=i;//初始化边表
sort(r,r+m,cmp);//给边集排序
for(int i=0;i<m;i++)
{
int e=r[i];
int x=find(u[e]);
int y=find(v[e]);//查找两个端点所在的集合
if(x!=y){ans+=w[e];p[x]=y;}//若两个集合不是同一个集合，合并集合
}
return ans;
}

最短路径问题旨在寻找图中两节点之间的最短路径，常用的算法有：floyd算法和dijkstra算法。
　　floyd算法是最简单的最短路径算法，可以计算图中任意两点间的最短路径  folyd算法的时间复杂度是O(N3),如果是一个没有边权的图，把相连的两点  间的距离设为dist[i][j] = 1，不相连的两点设为无穷大，用 floyd算法可以判断i,j两点是否有路径相连。

void floyd()
{
for(int k = 0; k < n; k ++){ //作为循环中间点的k必须放在最外一层循环
for(int i = 0; i < n; i ++){
for(int j = 0; j < n; j ++){
if(dist[i][j] > dist[i][k] + dist[k][j]){
dist[i][j] = dist[i][k] + dist[k][j];    //dist[i][j]得出的是i到j的最短路径
}
}
}
}
}

dijkstra算法用来计算从一个点到其他所有点的最短路径的算法，复杂度O(N2)。

void dijkstra(int s)   //s是起点
{
memset(visit, false, sizeof(visit));
visit[s] = true;
for(int i = 0; i < n; i ++)
{
dist[i] = graph[s][i];
if(i!=s && dist[i]!=INF)
path[i]=s;
else path[i]=-1;
 }

int index;
for(int i = 1; i < n; i ++){
int mincost = INF;
for(int j = 0; j < n; j ++){
if(!visit[j] && dist[j] < mincost){
mincost = dist[j];
index = j;
}
}
visit[index] = true;
for(int j = 0; j < n; j ++){
if(!visit[j] && dist[j] > dist[index] + graph[index][j])
{
dist[j] = dist[index] + graph[index][j];
path[j]=index;
 }
}
}
}
void show_path(int v,int s)
{
stack<int>st;
while(v!=s)
{
st.push(v);
v=path[v];
}
st.push(v);
while(!st.empty())
{
cout<<st.top<<" ";
st.pop();
}
}