最短路算法小结

poj1860,poj3259,poj1062,poj2253,poj1125,poj2240
邻接矩阵（Adjacency Matrix）：是表示顶点之间相邻关系的矩阵。
http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html
http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html
http://blog.csdn.net/zrjdds/article/details/6728332
http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html
STL http://blog.csdn.net/zy_dreamer/article/details/8939926
SFPA http://blog.sina.com.cn/s/blog_a46817ff01015g9h.html
http://www.cnblogs.com/hxsyl/archive/2012/07/01/2572334.html 115
*****Dijkstra-----
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

#define INF 0xffffff
#define M 201

int cost[M][M];//路径的权值
int d[M];//s到x最短距离
int used[M];//点是否用过
int n,m;

int s,e;//start end
int a,b,c;


void init(int v)//初始化 cost
{
    for(int i=0;i<v;i++)
        for(int j=0;j<v;j++)
        {
            cost[i][j]=INF;
        }
}

void dj(int s)
{
    int i,j;
    for(i=0;i<=n;i++)
    {
        d[i]=cost[s][i];
    }
    used[s]=1;
    d[s]=0;
/* 选其余点中距离s最短的那个点开始*/
    int k,p;
    for(i=0;i<=n;i++)
    {
        int mi=INF;
        for(j=0;j<n;j++)
        {
            if(!used[j] && mi>d[j])
            {
                mi = d[j];
                k = j;
            }
        }
        used[k] = true;

        for(p=0;p<n;p++)
        {
            if(!used[p]&&d[p]>d[k]+cost[k][p])//d[ax]+d[xb]<d[ab]不断更新dis
            {
                d[p]=d[k]+cost[k][p];
            }
        }
    }
}
int main()
{
    while(cin>>n>>m)
    {
        init(n);
        for(int i=0;i<m;i++)
        {
            cin>>a>>b>>c;
            if(cost[a][b]>c) {cost[a][b]=c;cost[b][a]=c;}//有权值的正常 没有权值的为INF
        }
        memset(used,0,sizeof(used));
        cin>>s>>e;

        dj(s);
        if(d[e]<INF) cout<<d[e]<<endl;
        else cout<<-1<<endl;
    }
    return 0;
}
**********************************************
#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #define MAX 0x7FFFFFFF
 #define N 1005
 int cls[N],map[N][N],vis[N],city[101],ans[101];
 int m,n,p,q;
 /*V为源点 */
 void Dijkstra(int v)
 {
     int i,j,min,next;
     /* 先用v到邻接点的距离初始化cls */
     for(i=1;i<=m;i++)
        cls[i]=map[v][i];
     memset(vis,0,sizeof(vis));
     vis[v]=1;//起点访问标志置1
     for (i=1;i<m;i++)//无等号
     {
         min=MAX;
         next=v;
         /*找出离集合最近的那个点next，以及该点到集合的距离min*/
         for (j=1;j<=m;j++)
         {
             if(!vis[j]&&cls[j]<min)
             {
                 next=j;
                 min=cls[j];
             }
         }
         vis[next]=1;
         for (j=1;j<=m;j++)
         {
            /*j点没有被访问过，j点和next点之间有通路，next点到j点的距离+集合到nxt的距离<集合到j的距离*/
             if(!vis[j]&&map[next][j]<MAX&&(min+map[next][j])<cls[j])
                 cls[j]=cls[next]+map[next][j];
         }
     }
 }
 int main()
 {
     int T,i,j;int a,b,c;int temp;
     scanf("%d",&T);
     while(T--)
     {
        temp=0x7FFFFFFF;
        for(i=0;i<N;i++)
            for(j=0;j<N;j++)
                map[i][j]=MAX;
        scanf("%d%d%d%d",&n,&m,&p,&q);
        /*  部队驻扎点 */
        for(i=1;i<=n;i++)
            scanf("%d",city+i);
         while(p--)
         {
             scanf("%d%d%d",&a,&b,&c);
             if(map[a][b]>c)
                map[a][b]=map[b][a]=c;
         }
         for(i=1;i<=n;i++)
            {
                memset(cls,0,sizeof(cls));
                Dijkstra(city[i]);
                ans[i]=cls[q];
                //printf("%d     %d       %d\n",cls[q],ans[i],cls[n]);
            }
        for(i=1;i<=n;i++)
            if(temp>ans[i])
                temp=ans[i];
        printf("%d\n",temp);
     }
     return 0;
 }
 /*
 error: invalid types `int[int]' for array subscript
 变量和数组同名
 */

******************************************************************************************************************
#include<iostream>
#include<stdio.h>
using namespace std;
#define inf 9999999
        int map[250][250];
        int n,m;
        int Floyd(int x,int y)
{
int t,i,j;
for(t=0; t<n; t++)
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
            if(map[i][j]>map[i][t]+map[t][j])
            {
                map[i][j]=map[i][t]+map[t][j];
            }
if(map[x][y]==inf) return -1;
else return map[x][y];
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int a,b,v,d,f,num;
        for(int i=0; i<=n; i++)
            for(int j=0; j<=n; j++)
                map[i][j]=map[j][i]=inf;
        for(int i=0; i<n; i++) //注意同一点的权值为0，刚开始wa在这儿
            map[i][i]=0;
        for(int i=0; i<m; i++)
        {
            cin>>a>>b>>v;
            if(map[a][b]>v)
                map[a][b]=map[b][a]=v;
        }
        cin>>d>>f;
        num=Floyd(d,f);
        cout<<num<<endl;
    }
    return 0;
}
******************************************************************
SPFA 
算法大致流程是用一个队列来进行维护。
初始时将源加入队列。每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于 Dist[u]，若小于则改进Dist[u]，
将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，
也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，
但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，
于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。

<span style="color:#339999;">/*
单源最短路径的算法最常用的是Dijkstra，些算法从时间复杂度来说为O（n^2),
但是面对含有负权植的图来说就无能为力了，此时Dellman-ford算法就有用了，
这咱算法是采用的是动态规化的思想，
但是1994年西南交通大学段凡丁发表了SPFA(Shortest Path Faster Algorithm)听这个名字就懂了，
这种算法在时间上一定很快了。它是对Dellman-ford的优化，
所以建议今后直接学SPFA。很多时候，给定的图存在负权边，
这时类似Dijkstra等算法便没有了用武之地，
而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。

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

在Bellman-Ford算法中，要是某个点的最短路径估计值更新了，
那么我们必须对所有边指向的终点再做一次松弛操作；在SPFA算法中，
某个点的最短路径估计值更新，
只有以该点为起点的边指向的终点需要再做一次松弛操作
只要最短路径存在，上述SPFA算法必定能求出最小值。*/
#include<iostream></span>
#include<algorithm>
#include<queue>
#include<stdio.h>
#include<string.h>
#define Maxn 100
#define Maxm 10000
#define Max 10000
using namespace std;

int used[Maxn],outqueue[Maxn],head[Maxn],low[Maxn],n,m;

struct Edge
{
       int to,w,next;
}edge[Maxm];

int SPFA (int start)
{
     queue<int>a;
     used[start] = 1;
     low[start] = 0;
     a.push(start);
     while (!a.empty())
     {
           int top = a.front();
           a.pop();
           outqueue[top]++;
           if (outqueue[top] > n) return false;//用来判断是否有环路
           for (int k = head[top]; k!= -1; k = edge[k].next)//宽搜每一条边
           {
               if (low[edge[k].to] > low[top] + edge[k].w)//对点进行松弛
                  low[edge[k].to] = low[top] + edge[k].w;
               if (!used[edge[k].to])
               {
                   used[edge[k].to] = 1;
                   a.push(edge[k].to);
               }
           }
     }
     return true;
}

int main()
{
    while (scanf ("%d%d", &n ,&m) != EOF)
    {
          memset (used, 0 ,sizeof(used));
          memset (head, -1 ,sizeof(head));
          memset (outqueue, 0 ,sizeof(outqueue));
          memset (low, Max, sizeof(low));
          int k = 0;
          while (m--)
          {
                int a,b,w;
                scanf ("%d%d%d", &a, &b, &w);
                edge[k].to = b;
                edge[k].w = w;
                edge[k].next = head[a];
                head[a] = k++;
          }
          cout<<SPFA(1)<<endl;
          if (SPFA(1))
             printf ("%d\n", low[n]);
          else
             printf ("no\n");
    }
}

************************************************************
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

#define inf 999999
#define M 2001

int n,m,s;
int dis[M];
int vis[M];
int map[M][M];

void init()
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
        {
            map[i][j]=inf;
        }
}
//void dj(int s)
//{
//    int i,j,k = 0;
//    int min;
//    memset(vis,0,sizeof(vis));  //初始时都没被访问过
//    for(i = 1; i <=n; i++)
//    {
//        dis[i] = map[s][i];
//    }
//    vis[s] = 1;  //第一个顶点即原点，被访问
//    dis[s] = 0; //s到s 即为0
//    for(i = 1; i < n; i++)
//    {
//        min = inf;
//        //找到最小的
//        for (j = 1; j <= n; j++)
//        {
//            if (!vis[j] && dis[j] < min)
//            {
//                min = dis[j];
//                k = j;   //最小的顶点
//            }
//        }
//        if (min == inf)
//        {
//            break;
//        }
//        vis[k] = 1; //k顶点被访问
//        //这里就是比较：直接到还是转一下再到
//       //我猜，你个笨蛋肯定会问：不能转多下吗？
//        //答曰：从源点一个一个向外扩展，具有最优子结构。每个dis[i]都保留着从s到i的最短距离。转多下的情况把它分解开，就知道了
//        for(j = 1; j <= n; j++)
//        {
//            if ( !vis[j] && dis[j] > dis[k] + map[k][j])
//            {
//                dis[j] = dis[k] + map[k][j];
//            }
//        }
//    }
//    return ;
//}
void dj(int s)
{
    int i,j,k=0;
    int mi;
    memset(vis,0,sizeof(vis));
    for(i=1;i<=n;i++)
        dis[i]=map[s][i];
    vis[s]=1;
    dis[s]=0;
    for(i=1;i<n;i++)
    {
        mi=inf;
        for(j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]<mi)
            {
                mi=dis[j];
                k=j;
            }
        }
        if(mi==inf)
            break;
        vis[k]=1;
        for(j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]>dis[k]+map[k][j])
                {
                    dis[j]=dis[k]+map[k][j];
                }
        }
    }
}
int main()
{
    int p,q,t,w,ww;//起点 终点 所耗费的时间
    int minx;
    while(~scanf("%d%d%d",&n,&m,&s))
    {
        memset(dis,0,sizeof(dis));

        init();//地图初始化

        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&p,&q,&t);
            if(t<map[q][p])
                map[q][p]=t;//因为是把目的地看做源点 所以必须所有的点顺得反过来
        }

        dj(s);
        scanf("%d",&w);
        minx=inf;

        for(int i=1; i<=w; i++)
        {
            scanf("%d",&ww);
            if(minx>dis[ww])
                minx=dis[ww];
        }
        if(minx!=inf)
            printf("%d\n",minx);
        else
            printf("-1\n");
    }
}
//void dj(int s)
//{
//    int i,j,k=0;
//    int mi;
//    memset(vis,0,sizeof(vis));
//    for(i=1; i<=n; i++)
//    {
//        dis[i]=map[s][i];
//    }
//    vis[s]=1;
//    dis[s]=0;//s→s为0
//    for(i=1; i<n; i++)
//    {
//        mi=inf;
//        for(j=1; j<=n; j++)
//        {
//            if(!vis[j]&&dis[j]<mi)
//            {
//                mi=dis[j];
//                k=j;
//            }
//        }
//        if(mi=inf)
//            break;
//        vis[k]=1;//k被访问过
//        for(j=1; j<=n; j++)
//        {
//            if(!vis[j]&&dis[j]>dis[k]+map[k][j])
//            {
//                dis[j]=dis[k]+map[k][j];
//            }
//        }
//
//    }
//    return ;
//}