3最短路的几种解法 ------例题< 最短路 >

点击进入例题   最短路　　　　　

我知道的有三种方法 1 : 深搜 每次  每次有更小的路径时  就更新   ,   2 :   Dijkstra    3 : floyd

前两种   是  单源 最短路径    ,     如果是 求 单源最短路径的话  就用前面的 两种   ,   但是 如果求的是 多源最短路径的话 最好是还用  floyd   时间复杂度 相对较低    .  用floyd 求单源最短路径的话 ....   时间复杂度 搞那么一点点 不过 程序实现简单 ,

1 : floyd 的 实现方法 

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<map>
#include<cctype>
using namespace std;
#define INF 99999999
int main()
{
    int e[][];
    int n,m,a,b,c,i,j,k;
    while(~scanf("%d %d",&n,&m)&&n!=&&m!=)
    {
        for(i=;i<=n;i++)      //     将  各个边  初始化 为 最大值
            for(j=;j<=n;j++)
                e[i][j]=INF;
            while(m--)
            {
                scanf("%d%d%d",&a,&b,&c);     //         确定边  和  边长
                e[b][a]=e[a][b]=c;
            }
            for(k=;k<=n;k++)    //Floyd核心算法...
            {
                for(i=;i<=n;i++)       //  所有的 路 都让   k  加进去试试
                {
                    for(j=;j<=n;j++)      //如果  从  i到j的路上 有k 走的会更轻松的话 , 那就让 k 去吧
                    {
                        if(e[i][j]>e[i][k]+e[k][j])      //   判断 是否会 更加轻松
                            e[i][j]=e[i][k]+e[k][j];
                    }
                }
            }

            printf("%d\n",e[][n]);
    }
}

2 : 深搜完成   .　　　　( 超时 ..... 数据处理应该是没有问题的   )

 #include<stdio.h>
 #include<string.h>
 #include<math.h>
 #include<iostream>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #include<stack>
 #include<string>
 #include<sstream>
 #include<map>
 #include<cctype>
 using namespace std;
 #define INF 99999999
 int n,m,a[][],result;
 vector<int>v[];
 void DFS(int star,int dis)
 {
     if(dis>=result)
         return;
     if(star==n)
     {
         result=result>dis?dis:result;
         return ;
     }
     for(int i=;i<v[star].size();i++)
     {
         if(a[star][v[star][i]]!=INF)
         {
             int w=a[star][v[star][i]];
             a[star][v[star][i]]=INF;
             a[v[star][i]][star]=INF;
             DFS(v[star][i],w+dis);
             a[star][v[star][i]]=w;
             a[v[star][i]][star]=w;
         }
     }
 }
 int main()
 {
     for(int i=;i<;i++)
         for(int j=;j<;j++)
         a[i][j]=INF;
     while(scanf("%d%d",&n,&m),(m||m))
     {
         result=INF;
         for(int i=;i<m;i++)
         {
             int d,b,c;
             scanf("%d%d%d",&d,&b,&c);
             v[d].push_back(b);
             v[b].push_back(d);
             a[d][b]=c;
             a[b][d]=c;
         }
         DFS(,);  //  从  1  到  n .
         printf("%d\n",result);
     }
 }

3 : Dijkstra   ( 也就这一个比较有意思一点  )   < 归根结底 所有的算法 都是 模拟  ... >

 #include<stdio.h>
 #include<string.h>
 #include<iostream>
 using namespace std;
 #define N 0x1f1f1f1f
 int w[][];
 int d[];
 int ans,vis[];
 int n,m;
 void Dij()     //  Dijkstra
 {
     int i,j,k,v,tmp;
     memset(vis,,sizeof(vis));
     for(i=;i<=n;i++)               //  图 中 每个节点 和  1  的距离  不是直接相邻的 就是   正无穷
         d[i]=w[][i];
     d[]=;
     vis[]=;
     for(i=;i<=n;i++)
     {
         tmp=N;
         for(j=;j<=n;j++)
         {
             if(tmp>d[j]&&!vis[j])      //  从中 找到一个  和  1 最近的点      (   这就是 怪姥姥讲的 已经有的 确定集合了吧    )
             {
                 tmp=d[j];
                 v=j;          // 记录下来 那一个端点的 标号
             }
         }
         vis[v]=;               //  最短的 端点 假如集合   ,   标记为  已经在  集合以内
         for(k=;k<=n;k++)
         {
             if(!vis[k])         //      将所有  集合之外 但是  和 集合之中 最少一个元素相连的元素 的长度  算一下
             d[k]=min(d[k],d[v]+w[v][k]);  // 但是  不让他们加进去  一会 在上面 检查一个最小的 假如已经确定长度的  集合之中
         }
     }
 }
 int main()
 {
     printf("%d",N);
     while(~scanf("%d%d",&n,&m))
     {
         if(n==&&m==)break;
         for(int i=;i<=n;i++)
         {
             for(int j=;j<=n;j++)
             {
                 w[i][j]=0x1f1f1f1f;
             }
         }
         for(int i=;i<m;i++)
         {
             int a,b,dis;
             scanf("%d%d%d",&a,&b,&dis);
             if(w[a][b]>dis)
             w[a][b]=w[b][a]=dis;
         }
         Dij();
         printf("%d\n",d[n]);
     }
 }