最小生成树（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();
    }
}