最短路——畅通工程续

最新推荐文章于 2020-05-26 16:21:22 发布
最新推荐文章于 2020-05-26 16:21:22 发布
阅读量729 收藏
点赞数
分类专栏： C&&C++ 文章标签： 最短路 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Perfect_Accepted/article/details/38849403
版权 

  
  

   
   
Description

   
   

    
    

     
     某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。 

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。
    
    

    
    

     
      
    
    

   
   

  
  

  
  

   
   
Input

   
   

    
    

     
     本题目包含多组数据，请处理到文件结束。 
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。 
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。 
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。
    
    

    
    

     
      
    
    

   
   

  
  

  
  

   
   
Output

   
   

    
    

     
     对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1. 

    
    

    
    

     
      
    
    

   
   

  
  

 
 

  
  
Sample Input

   
   

    
    

     
     
      
      

       
        3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2 
      
      

    
    

    
    

     
      
    
    

   
   

 
 

 
 

  
  
Sample Output

  
  

   
   

    
    
     
     

      
       2
-1 
     
     

   
   

   
   

    
     
   
   

  
  

 
 

//dijkstra算法
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
#define N 10000
int inf=99999;
int Map[N][N];
int dis[N];
int vis[N];
int n,m;
int s,e;
void dijkstra(int n)
{
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
    {
        dis[i]=Map[s][i];
    }
    vis[s]=1;
    for(int i=0;i<n-1;i++)
    {
        int pos;
        int Min=inf;
        for(int j=0;j<n;j++)
        {
           if(!vis[j]&&dis[j]<Min)
           {
               Min=dis[j];
               pos=j;
           }
        }
        vis[pos]=1;
        for(int j=0;j<n;j++)
        {
            if(!vis[j]&&dis[j]>dis[pos]+Map[pos][j])
            {
                dis[j]=dis[pos]+Map[pos][j];
            }
        }
    }
    if(dis[e]>=inf)
        printf("-1\n");
    else
        printf("%d\n",dis[e]);
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                Map[i][j]=inf;
                Map[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(Map[a][b]>c)
                Map[a][b]=Map[b][a]=c;
        }
        scanf("%d%d",&s,&e);
        dijkstra(n);
    }
     return 0;
}
//FLOYD算法
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
#define N 10000
int inf=99999;
int Map[N][N];
int dis[N];
int vis[N];
int n,m;
int s,e;
void floyd()
{
   for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        if(Map[i][k]!=inf&&Map[j][k]!=inf&&Map[i][j]>Map[i][k]+Map[k][j])
        Map[i][j]=Map[i][k]+Map[k][j];
   if(Map[s][e]!=inf)
    printf("%d\n",Map[s][e]);
   else
    printf("-1\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                Map[i][j]=inf;
                Map[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(Map[a][b]>c)
                Map[a][b]=Map[b][a]=c;
        }
        scanf("%d%d",&s,&e);
        floyd();
    }
     return 0;
}
//Bellman-Ford
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
#define N 10000
int inf=99999;
int Map[N][N];
int dis[N];
int n,m;
int s,e;
void bellman()
{
   for(int i=0;i<n;i++)
   {
       dis[i]=Map[s][i];
   }
   for(int i=0;i<n-1;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(j!=s)
           {
               for(int k=0;k<n;k++)
               {
                   if(dis[j]>dis[k]+Map[k][j])
                    dis[j]=dis[k]+Map[k][j];
               }
           }
       }
   }
   if(dis[e]!=inf)
    printf("%d\n",dis[e]);
   else
    printf("-1\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                Map[i][j]=inf;
                Map[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(Map[a][b]>c)
                Map[a][b]=Map[b][a]=c;
        }
        scanf("%d%d",&s,&e);
        bellman();
    }
     return 0;
}
//SPFA
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
const int  N=10000;
const int inf=99999;
int Map[N][N];
int dis[N];
int vis[N];
int que[N];
int n,m;
int s,e;
void SPFA()
{
   memset(vis,0,sizeof(vis));
   int in=0,out=0;
   for(int i=0;i<n;i++)
   {
       dis[i]=inf;
   }
   dis[s]=0;
   que[in++]=s;
   vis[s]=1;
   while(out<in)
   {
       int p=que[out++];
       for(int i=0;i<n;i++)
       {
           if(dis[i]>dis[p]+Map[p][i])
           {
               dis[i]=dis[p]+Map[p][i];
               if(!vis[i])
               {

                   que[in++]=i;
                   vis[i]=1;
               }

           }
       }
       vis[p]=0;
   }
   if(dis[e]!=inf)
    printf("%d\n",dis[e]);
   else
    printf("-1\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                Map[i][j]=inf;
                Map[i][i]=0;
        }
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(Map[a][b]>c)
                Map[a][b]=Map[b][a]=c;
        }
        scanf("%d%d",&s,&e);
       SPFA();
    }
     return 0;
}
//SPFA前相星式
#include "iostream"
#include"cstdio"
#include"cstring"
#include"cstdlib"
using namespace std;
const int N=1000;
const int inf=99999;
int dis[N];
int vis[N];
int que[N];
int n,m;
int s,e;
int cnt;
struct Edge
{
    int w;
    int v;
    int next;
}edge[N];
int head[N];
void init()
{
     memset(vis,0,sizeof(vis));
     memset(head,-1,sizeof(head));
     for(int i = 0;i<n;i++)
     {
            dis[i] = inf;
     }
     cnt=0;
}
void add(int u,int v,int w)
{
   edge[cnt].v = v;
   edge[cnt].w = w;
   edge[cnt].next = head[u];
   head[u] = cnt++;
}
void SPFA()
{
   int in=0,out=0;
   que[in++]=s;
    vis[s] = 1;
    dis[s] = 0;
    while(in>=out)
    {
        int p=que[out++];
        if(head[p]!=-1)
        {
            for(int i = head[p];i!=-1;i= edge[i].next)
            {
                if(dis[edge[i].v]>dis[p] + edge[i].w)
                {
                    dis[edge[i].v] = dis[p] + edge[i].w ;
                      if(!vis[edge[i].v])
                   {
                   que[in++]=edge[i].v;
                    vis[edge[i].v] = 1;
                  }
                }
             }
        }
          vis[p] = 0;
    }
    if(dis[e]<inf)
        printf("%d\n",dis[e]);
    else
        printf("-1\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);

            add(b,a,c);add(a,b,c);
        }
        scanf("%d%d",&s,&e);
        SPFA();
    }
    return 0;
}

QiujieDong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路——Floyd
01-27
最短路模板 by 程序猿小周 时间复杂度：O(n^3) 适用于：求单源最短路
matlab最短路.txt
08-11
matlab最短路.txt
Python 基础 —— float("inf") 无穷的相关问题
HeatDeath的博客
05-09 4410
Python中可以用如下方式表示正负无穷：float("inf"), float("-inf")利用 inf 做简单加、乘算术运算仍会得到 inf>>> 1 + float('inf') inf >>> 2 * float('inf') inf 但是利用 inf 乘以0会得到 not-a-number(NaN)：>>> 0 * float("inf") nan除了inf外的其他数除以inf，会得到0
C语言 表示无穷大数 INF
皮酱的博客
05-26 8683
（一）（1 << 31) - 1 注意括号要加，因为位运算符的优先级没有算术运算符高。 （二） 2^30 - 1 更为常用。 2^30 - 1 等价于 0x3fffffff 代码如下 const int INE= (1 << 30) - 1; const int INF = Ox3fffffff;
最短路—— 畅通工程续
空白页
02-21 645
畅通工程续 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description 某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另
畅通工程续——最短路
Gyd＆01
10-11 636
畅通工程续 Problem Description 某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。 现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。   Input 本题目包含多组数据，请处理到文
最短路问题及其应用.pdf
03-30
最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf最短路问题及其应用.pdf
TSP TS_最短路
09-25
求解旅行商问题 用了图神经网路 优化路径
数学建模-最短路问题
02-26
数学建模-最短路问题
二叉树——已知二叉树先序，建树，并输出中序、后序，并求树叶数和深度
Perfect_Accepted
08-22 1557
Description        已知一个按先序序列输入的字符序列，如abc,,de,g,,f,,,(其中逗号表示空节点)。请建立二叉树并按中序和后序方式遍历二叉树，最后求出叶子节点个数和二叉树深度。 Input   输入一个长度小于50个字符的字符串。 Output 输出共有4行：  第1行输出中序遍历序列； 第2行输出后序遍历序列； 第3行输出叶子节
二叉树学习-已知中序、后序，求先序
Perfect_Accepted
08-22 1215
#include #include"cstdio" #include"cstring" #include"cstdlib" using namespace std; char ins[1050],pos[1050]; struct node { char data; node *lch,*rch; }; node *build(char *ins ,char*pos,int n)
指针——统计元音字母
Perfect_Accepted
08-22 1006
#include #include #include"string.h" int main() { int n,m,i,k,b[5]={0}; char a[120]={'\0'},*p=a,x; scanf("%d",&m); scanf("%c",&x); for (k=1;km;k++) { gets(a); n=strlen(a); fo
进制的转换——进制和回文判断相结合
Perfect_Accepted
08-29 905
#include"stdio.h" #include"string.h" #include"stdlib.h" #include"math.h" using namespace std; char b[100]; int a[350]; int c[350]; int k; int hw(int s[]) { int cnt=0; int x=k-1; while(cntx
二叉树——多组输入，知先、中序，输出后序
Perfect_Accepted
08-22 816
Description 已知一棵二叉树的前序遍历和中序遍历，求二叉树的后序遍历。Input 输入数据有多组，第一行是一个整数t (tOutput每组第一行输出二叉树的后序遍历序列，第二行输出二叉树的层次遍历序列Sample Input2 abdegcf dbgeafc xnliu lnixuSample Outputdgebfca abcdefg linux xnuli #include #i
二叉树——已知先序、中序，求后序
Perfect_Accepted
08-22 709
Description 输入二叉树的先序遍历序列和中序遍历序列，输出该二叉树的后序遍历序列。 Input 第一行输入二叉树的先序遍历序列；  第二行输入二叉树的中序遍历序列。 Output 输出该二叉树的后序遍历序列。 Sample Input ABDCEF BDAECF Sample Output DBE
并查集——信仰最多的宗教
Perfect_Accepted
08-22 645
Submit StatusDescriptionThere are so many different religions in the world today that it is difficult to keep track of them all. You are interested in finding out how many different religions students
贪心——防空
Perfect_Accepted
08-22 626
Description 某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最
指针——判断合法字符
Perfect_Accepted
08-22 609
#include #include #include"string.h" int main() { int n,m,i,j; char a[60]={'\0'},*p=a,x; scanf("%d",&n); scanf("%c",&x); for(j=1;jn;j++) { gets(a); m=strlen(a); i=m-9;
LOJ6354 & 洛谷4366：[Code+#4]最短路——题解
最新发布
05-17
这道题需要使用 Dijkstra 算法来解决。 Dijkstra 算法是一种贪心算法，用于解决没有负权边的单源最短路径问题。算法的基本思想是：从源点开始，每次选择当前最短路径的节点，并更新其周围节点的距离。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值