最短路算法--模板

迪杰斯特拉算法（Dijkstra）：

Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。

主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

#include <iostream>
using namespace std; 
const int maxnum = 100;
const int maxint = 999999;
 
// 各数组都从下标1开始
int dist[maxnum];     // 表示当前点到源点的最短路径长度
int prev[maxnum];     // 记录当前点的前一个结点
int c[maxnum][maxnum];   // 记录图的两点间路径长度
int n, line;             // 图的结点数和路径数
 
// n -- n nodes
// v -- the source node
// dist[] -- the distance from the ith node to the source node
// prev[] -- the previous node of the ith node
// c[][] -- every two nodes' distance
void Dijkstra(int n, int v, int *dist, int *prev, int c[maxnum][maxnum])
{
     bool s[maxnum];    // 判断是否已存入该点到S集合中
     for(int i=1; i<=n; ++i)
     {
          dist[i] = c[v][i];
          s[i] = 0;     // 初始都未用过该点
          if(dist[i] == maxint)
           prev[i] = 0;
          else
           prev[i] = v;
     }
     dist[v] = 0;
     s[v] = 1;
     // 依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
     // 一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
        // 注意是从第二个节点开始，第一个为源点
     for(int i=2; i<=n; ++i)
     {
          int tmp = maxint;
          int u = v;
          // 找出当前未使用的点j的dist[j]最小值
          for(int j=1; j<=n; ++j)
           if((!s[j]) && dist[j]<tmp)
           {
                u = j;              // u保存当前邻接点中距离最小的点的号码
                tmp = dist[j];
           }
          s[u] = 1;    // 表示u点已存入S集合中
         
          // 更新dist
          for(int j=1; j<=n; ++j)
           if((!s[j]) && c[u][j]<maxint)
           {
                int newdist = dist[u] + c[u][j];
                if(newdist < dist[j])
                {
                     dist[j] = newdist;
                     prev[j] = u;
                }
           }
     }
} 
// 查找从源点v到终点u的路径，并输出(写题时可以省略)
void searchPath(int *prev,int v, int u)
{
     int que[maxnum];
     int tot = 1;
     que[tot] = u;
     tot++;
     int tmp = prev[u];
     while(tmp != v)
     {
          que[tot] = tmp;
          tot++;
          tmp = prev[tmp];
     }
     que[tot] = v;
     for(int i=tot; i>=1; --i)
      if(i != 1)
       cout << que[i] << " -> ";
      else
       cout << que[i] << endl;
}
 
int main()
{
 
 cin >> n; // 输入结点数
 cin >> line; // 输入路径数
 int p, q, len;  // 输入p, q两点及其路径长度
 
 // 初始化c[][]为maxint
 for(int i=1; i<=n; ++i)
  for(int j=1; j<=n; ++j)
   c[i][j] = maxint;
 
 for(int i=1; i<=line; ++i)  
 {
      cin >> p >> q >> len;
      if(len < c[p][q])       // 有重边
      {
           c[p][q] = len;      // p指向q
           c[q][p] = len;      // q指向p，这样表示无向图
      }
 }
 for(int i=1; i<=n; ++i)
  dist[i] = maxint;
 for(int i=1; i<=n; ++i)
 {
      for(int j=1; j<=n; ++j)
       printf("%8d", c[i][j]);
      printf("
");
 }
 
 Dijkstra(n, 1, dist, prev, c);
 //最短路径长度
 cout << "源点到最后一个顶点的最短路径长度: " << dist[n] << endl;
 //路径
 cout << "源点到最后一个顶点的路径为: ";
 searchPath(prev, 1, n);
}

#include <stdio.h>
#include <string.h>
#define inf 99999999
#define MAX 100

int n; 
int dis[MAX];
int path[MAX][MAX];
int visit[MAX];
int dijkstra () //起点从1开始  输出起点到终点的最短路径 
{
    int i,j,pos,minn;
    for (i = 1; i <= n; i ++)
    {
        dis[i] = path[1][i];
        visit[i] = 0;
    }
    dis[1] = 0;
    visit[1] = 1;
    for(i = 1;i <= n; i ++)
    {
        minn = inf;
        for (j = 1; j <= n; j ++)
            if (!visit[j] && dis[j] < minn)
            {
                minn = dis[j];
                pos = j;
            }    
        visit[pos] = 1;
        for (j = 1; j <= n; j ++)
        {
            if (!visit[j] && dis[j] > dis[pos]+path[pos][j])
                dis[j] = dis[pos]+path[pos][j];
        }
    }
    return dis[n]; 
}

弗洛伊德算法（Floyd算法）：

Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，

同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N³)，空间复杂度为O(N²)。

a.从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。 　　

b.对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短。如果是更新它。

#include <stdio.h>
#include <string.h>
#define inf 99999999
#define MAX 100

int n;
int path[MAX][MAX];
int floyd() //任意两点之间的最短路径 
{
    int i,j,k;
    for (k = 1; k <= n; k ++)
        for (i = 1; i <= n; i ++)
            for (j = 1; j <= n; j ++)
                if (path[i][j] > path[i][k]+path[k][j])
                    path[i][j] = path[i][k]+path[k][j];
    return path[1][n];
}

Mellman-Frod算法：

适用条件&范围：

单源最短路径(从源点s到其它所有顶点v);

有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);

边权可正可负(如有负权回路输出错误提示);

Bellman－Ford算法可以大致分为三个部分
第一，初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。
第二，进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。
第三，遍历途中所有的边（edge（u，v）），判断是否存在这样情况：
d（v） > d (u) + w(u,v)
则返回false，表示途中存在从源点可达的权为负的回路。

#include<iostream>  
#include<cstdio>  
using namespace std;  
  
#define MAX 0x3f3f3f3f  
#define N 1010  
int nodenum, edgenum, original; //点，边，起点  
  
typedef struct Edge //边  
{  
    int u, v;  
    int cost;  
}Edge;  
  
Edge edge[N];  
int dis[N], pre[N];  
  
bool Bellman_Ford()  
{  
    for(int i = 1; i <= nodenum; ++i) //初始化  
        dis[i] = (i == original ? 0 : MAX);  
    for(int i = 1; i <= nodenum - 1; ++i)  
        for(int j = 1; j <= edgenum; ++j)  
            if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //松弛（顺序一定不能反~）  
            {  
                dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;  
                pre[edge[j].v] = edge[j].u;  
            }  
            bool flag = 1; //判断是否含有负权回路  
            for(int i = 1; i <= edgenum; ++i)  
                if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
                {  
                    flag = 0;  
                    break;  
                }  
                return flag;  
}  
  
void print_path(int root) //打印最短路的路径（反向）  
{  
    while(root != pre[root]) //前驱  
    {  
        printf("%d-->", root);  
        root = pre[root];  
    }  
    if(root == pre[root])  
        printf("%d
", root);  
}  
  
int main()  
{  
    scanf("%d%d%d", &nodenum, &edgenum, &original);  
    pre[original] = original;  
    for(int i = 1; i <= edgenum; ++i)  
    {  
        scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);  
    }  
    if(Bellman_Ford())  
        for(int i = 1; i <= nodenum; ++i) //每个点最短路  
        {  
            printf("%d
", dis[i]);  
            printf("Path:");  
            print_path(i);  
        }  
    else  
        printf("have negative circle
");  
    return 0;  
}  

#include <stdio.h>
#include <string.h>
#define inf 99999999
#define MAX 100

struct land 
{
    int x,y,z;        
}path[MAX]; 
void add(int u,int v,int w) //从u到v路径为w
{
    path[ans].x = u;
    path[ans].y = v;
    path[ans].z = w;
    ans ++;
} 
int n; //n个节点
int ans; //ans条路 
int path[MAX][MAX];
bool Bellman_ford() //判断是否出现正环或负环
{
    int i,j;
    for (i = 1; i <= n; i ++)
        dis[i] = inf;
    dis[1] = 0;
    
    for (i = 1; i < n; i ++)  //n-1次循环
    {
        bool flag = false;  //优化 
        for(j = 0; j < m; j ++)  //松弛m条路
            if(dis[path[j].y] > dis[path[j].x]+path[j].z)
            {
                dis[path[j].y] = dis[path[j].x]+path[j].z;
                flag = true;
            }
        if (!flag)  //不能松弛，表示一定不存在负权值回路 
            return false;
    }
    
    for (j = 0; j < m; j ++)
        if (dis[path[j].y] > dis[path[j].x]+path[j].z)
            return true;
    return false;
} 

SPFA算法：

推荐博客：http://www.cnblogs.com/scau20110726/archive/2012/11/18/2776124.html

　　　　　http://blog.csdn.net/muxidreamtohit/article/details/7894298

适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止

以POJ1511为例

#include <stdio.h>
#include <string.h>
#define inf 9999999999
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
struct node
{
    int to;
    int w;
    int next;
};
queue <int > q;
int n,m;
node list[1000010];
node list1[1000010];
int vis[1000010];
int dis[1000010];
int h1[1000010];
int h2[1000010];
void spfa()
{
    int i,j,u;
    for (i = 1; i <= n; i ++)
    {
        dis[i] = inf;
        vis[i] = 0;
    }
    q.push(1);
    dis[1] = 0;
    vis[1] = 1;

    while (!q.empty())
    {
        u = q.front();
        q.pop();
        vis[u] = 0;
        for (j = h1[u]; j ; j = list[j].next)
        {
            if (dis[list[j].to] > dis[u]+list[j].w)
            {
                dis[list[j].to] = dis[u]+list[j].w;
                if (!vis[list[j].to])
                {
                    q.push(list[j].to);
                    vis[list[j].to] = 1;
                }
            }
        }
    }
}
void spfa1()
{
    int i,j,u;
    for (i = 1; i <= n; i ++)
    {
        dis[i] = inf;
        vis[i] = 0;
    }
    q.push(1);
    dis[1] = 0;
    vis[1] = 1;

    while (!q.empty())
    {
        u = q.front();
        q.pop();
        vis[u] = 0;
        for (j = h2[u]; j ; j = list1[j].next)
        {
            if (dis[list1[j].to] > dis[u]+list1[j].w)
            {
                dis[list1[j].to] = dis[u]+list1[j].w;
                if (!vis[list1[j].to])
                {
                    q.push(list1[j].to);
                    vis[list1[j].to] = 1;
                }
            }
        }
    }
}
int main ()
{
    int i,j,t,u,v,w,ans;
    scanf("%d",&t);
    while (t --)
    {
        scanf("%d%d",&n,&m);
        memset(h1,0,sizeof(h1));
        memset(h2,0,sizeof(h2));
        for (ans = 1,i = 0; i < m; i ++)
        {
            scanf("%d%d%d",&u,&v,&w);
            node temp = {v,w,0};
            list[ans] = temp;
            list[ans].next = h1[u];
            h1[u] = ans;
            temp.to = u;
            list1[ans] = temp;
            list1[ans].next = h2[v];
            h2[v] = ans;
            ans ++;
        }
        long long sum = 0;
        spfa();
        for (i = 1; i <= n; i ++)
            sum += dis[i];
        spfa1();
        for (i = 1; i <= n; i ++)
            sum += dis[i];
        printf("%lld
",sum);
    }
    return 0;
}