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

int prime(int cur)
{
    int index = cur;
    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] && dist[j] < mincost){
                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;    
}

Prime 算法

　kruskal算法的基本思想：

　　1. 首先我们把所有的边按照权值先从小到大排列；

　　2. 接着按照顺序选取每条边，如果这条边的两个端点不属于同一集合，那么就将它们合并，直到所有的点都属于同一个集合为止。

　　其中用到了数据结构中的并查集。有关并查集的操作可以参考博客 http://blog.csdn.net/luomingjun12315/article/details/47373345

　　kruskal算法讲解推荐博客 http://www.cnblogs.com/skywang12345/p/3711500.html#anchor6

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <cmath>
#define MAX_SIZE 1010
 
using namespace std;
 
int n, m;
int Tree[MAX_SIZE];
 
int findRoot(int x){//find the root of x
    if(Tree[x]==-1) return x;
    else{
        int tmp = findRoot(Tree[x]);//continue the find
        Tree[x] = tmp;//change the root of x to tmp
        return tmp;
    }
     
}
int main(){
    while(scanf("%d",&n)!=EOF && n!=0){//when n==0 and jump out of the loop
        scanf("%d",&m);
        for(int i = 1 ; i <= n ; i++)//init
            Tree[i] = -1;
         
        while(m--){
            int a,b;
            scanf("%d%d",&a,&b);
            a = findRoot(a);//find the root of a
            b = findRoot(b);//find the root of b
            if(a!=b) Tree[a]=b;//merge those two sets to the same aggregates
        }
         
        int ans = 0 ;
        for(int i = 1 ; i <= n ; i++){
            if(Tree[i]==-1) ans++;//calculate the total numbers of aggregates
        }
        printf("%d
",ans-1);
    }
    return 0;
}

kruskal 算法

四、最短路径算法

　　最短路径问题旨在寻找图中两节点之间的最短路径，常用的算法有：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的最短路径 
                }     
            }    
        }    
    }    
}

Floyd 算法

　　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];
    }
     
    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];
            }    
        }    
    }
}

dijkstra 算法

五、图论大礼包

　　图论500题 http://blog.csdn.net/luomingjun12315/article/details/47438607

相关阅读:
N皇后问题
 SDNU1349.快速幂入门
 SDNU1522.陆历川学数学
 埃氏筛
 快速幂
 string函数
 Golang介绍以及安装
 Promise解决回调地狱(多层调用问题)
JavaScript动画相关
 ES6简单语法
原文地址：https://www.cnblogs.com/zpfbuaa/p/6732997.html

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

题目1447：最短路 题目链接：http://ac.jobdu.com/problem.php?pid=1447

题目1008：最短路径问题 题目链接：http://ac.jobdu.com/problem.php?pid=1008

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

题目1447：最短路题目链接：http://ac.jobdu.com/problem.php?pid=1447

题目1008：最短路径问题题目链接：http://ac.jobdu.com/problem.php?pid=1008