最短路径

最新推荐文章于 2021-09-09 07:49:47 发布
最新推荐文章于 2021-09-09 07:49:47 发布
阅读量615 收藏 2
点赞数
分类专栏： NOIP复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shm20000412/article/details/52776021
版权

Floyed算法 O(N^3)

适用于出现负边权的情况

(a)初始化：点u、v如果有边相连，则dis[u][v]=w[u][v]。
   如果不相连，则dis[u][v]=0x7fffffff。

(b)for(k=1;k<=n;k++)
    for(i=1;i<=n;i++)
     for(j=1;j<=n;j++)
       if(dis[i][j]>dis[i][k]+dis[k][j])

(c)算法结束：dis[i][j]得出的就是从i到j的最短路径

【例题】

Description

平面上有n个点（n<=100），每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点间的直线距离。现在的任务是找出从一点到另一点之间的最短路径。

Input

第一行一个整数n。
此后的n行，每行两个整数x和y，描述了一个点的坐标。（第i+1行描述的是第i个点）
第n+2行一个整数m，表示图中连线的个数。
此后的m行，每行描述一条连线，由两个整数i和j组成，表示第i个点和第j个点之间有连线。
最后一行两个整数s和t，分别表示源点和目标点。

Output

仅一行，一个实数（保留两位小数），表示从s到t的最短路径长度。

Sample Input

5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5

Sample Output

3.41

【代码】

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
int a[101][3];
double f[101][101];
using namespace std;
int main()
{
    int n,m;
    int x,y;
    int s,t;
    cin>>n;
    for(int i=1;i<=n;i++)
     cin>>a[i][1]>>a[i][2];
    cin>>m;
    memset(f,0x7f,sizeof(f));
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        f[y][x]=f[x][y]=sqrt(pow(double(a[x][1]-a[y][1]),2)+pow(double(a[x][2]-a[y][2]),2));
    }
    cin>>s>>t;
    for(int k=1;k<=n;k++)
     for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
       if((i!=j)&&(i!=k)&&(j!=k)&&(f[i][k]+f[k][j]<f[i][j]))
        f[i][j]=f[i][k]+f[k][j];
    printf("%.2lf",f[s][t]);
}

Dijkstra算法 O(n^2)

【基本结构】

int s[maxn];//用来记录某一点是否被访问过  
int map[maxn][maxn];//地图  
int dis[maxn];//从原点到某一个点的最短距离(一开始是估算距离)

【模板】

int map[N][N];
int dis[N];
int book[N];
int n,target;
int dijkstra(int v)
{
    for(int i=1;i<=n;i++)//book数组初始化
    {
      book[i]=0;
      dis[i]=map[v][i];//初始化dis数组，这里是1号顶点到其余各个顶点的初始路程 
      book[1]=1;
    } 
    for(int i=1;i<n;i++)
    {
        int min=99999999;
        int u;
        for(int j=1;j<=n;j++)//寻找目前的最短路径的最小点 
        {
            if(book[j]==0&&dis[j]<min)
            {
                min=dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(int v=1;v<=n;v++)
        {
            if(map[u][v]<99999999)
            {
              if(dis[v]>dis[u]+map[u][v])
              {
                dis[v]=dis[u]+map[u][v];
              }
            }
        }
    }
    return dis[target];
}

【题目特征】
　　给出点的数目、边的数目、起点和终点、边的信息(并且边不包含负边权的值).

　　求从起点到终点的最短路径的距离

　　起点：用于dijkstra(int v)中的v

　　终点：用于return dis[target]中的target
　　
　　边的信息：用于初始化map[][]

【例题】
Description
有n个站，求从1站到n站的最短路线。

Input
输入第一行n和m, n表示有n个站，m表示有m条道路，(n,m<100)接下来m行每一行输入三个数a,b,d,表示a和b之间有一条长为d 的路。

Output
输出从1到n的最短距离。

Sample Input
5 4
1 2 1
1 5 5
2 4 2
4 5 1
2 1
1 2 3

Sample Output
4
3

【代码】

Floyd算法实现：

#include<iostream>
#include<cstdio>
using namespace std;
int e[101][101];
int n,m;
void initial()
{
    for(int i=1;i<=n;i++)
     for(int j=1;j<=n;j++)
      if(i==j)
       e[i][j]=0;
      else 
       e[i][j]=99999999;
}
void floyd()
{
    for(int k=1;k<=n;k++)
     for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
       if(e[i][j]>e[i][k]+e[k][j])
        e[i][j]=e[i][k]+e[k][j];
}
int main()
{
    while((scanf("%d%d",&n,&m))!=EOF)
    {
        initial();
        for(int i=1;i<=m;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            e[a][b]=e[b][a]=c;
        }
        floyd();
        cout<<e[1][n]<<endl;
    }
}
Dijkstra算法实现：

#include<iostream>
#include<cstdio>
int map[101][101];
int dis[101];
int book[101];
int n,target;
using namespace std;
int dijkstra(int v)
{
    for(int i=1;i<=n;i++)//book数组初始化
    {
      book[i]=0;
      dis[i]=map[v][i];//初始化dis数组，这里是1号顶点到其余各个顶点的初始路程 
      book[1]=1;
    } 
    for(int i=1;i<n;i++)
    {
        int min=99999999;
        int u;
        for(int j=1;j<=n;j++)//寻找目前的最短路径的最小点 
        {
            if(book[j]==0&&dis[j]<min)
            {
                min=dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(int v=1;v<=n;v++)
        {
            if(map[u][v]<99999999)
            {
              if(dis[v]>dis[u]+map[u][v])
              {
                dis[v]=dis[u]+map[u][v];
              }
            }
        }
    }
    return dis[target];
} 
int main()
{
    int m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=n;i++)//初始化 
         for(int j=1;j<=n;j++)
          if(i==j)
           map[i][j]=0;
          else
           map[i][j]=9999999;

        for(int i=1;i<=m;i++)//读入边 
        {
          int a,b,c;
          cin>>a>>b>>c;
          map[a][b]=map[b][a]=c;
        }
        target=n;
        int ans=dijkstra(1);
        cout<<ans<<endl;
    }
    return 0;
}

Bellman—Ford 算法 O（NE）

算法时间复杂度：O（NE），N是顶点数，E是边数。

能够实现负边权，但无法处理负权回路的情况

【基本结构】

struct Edge
{
    int u;
    int v;
    int weight;
};
Edge edge[101];
int dis[101];//表示原点到i的距离，一开始为估算距离

【模板】

bool bellman_ford()
{
    for(int i=1;i<=n;i++)//初始化 
      dis[i]=99999999;
    dis[source]=0;//源节点到自己的距离为0
    /********核心语句**********/
    for(int i=1;i<n;i++)
      for(int j=1;j<=m;j++)
        if(dis[edge[j].v]>dis[edge[j].u]+edge[j].weight)
         dis[edge[j].v]=dis[edge[j].u]+edge[j].weight;
    if(dis[edge[j].u]>dis[edge[j].v]+edge[j].weight)
      dis[edge[j].u]=dis[edge[j].v]+edge[j].weight;

    for(int j=1;j<=m;j++)//判断是否有负边权的边
    {
        if(dis[edge[j].v]>dis[edge[j].u]+edge[j].weight)
          return false;
    }
    return true;    
}

【例题代码】

#include<iostream>
#include<cstdio>
using namespace std; 
struct Edge
{
    int u;
    int v;
    int weight;
};
Edge edge[101];//用来储存边 
int dis[101];//表示原点到i的距离，一开始为估算距离
int source;
int n,m;
bool bellman_ford()
{
    for(int i=1;i<=n;i++)//初始化 
      dis[i]=99999999;
    dis[source]=0;//源节点到自己的距离为0
    for(int i=1;i<n;i++)
      for(int j=1;j<=m;j++)
      {
        if(dis[edge[j].v]>dis[edge[j].u]+edge[j].weight)
          dis[edge[j].v]=dis[edge[j].u]+edge[j].weight;
        if(dis[edge[j].u]>dis[edge[j].v]+edge[j].weight)
          dis[edge[j].u]=dis[edge[j].v]+edge[j].weight;
      }
    for(int j=1;j<=m;j++)//判断是否有负边权的边
    {
        if(dis[edge[j].v]>dis[edge[j].u]+edge[j].weight)
          return false;
    }
    return true;    
} 
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=1;i<=m;i++)
        {
            cin>>edge[i].u>>edge[i].v>>edge[i].weight;
        }
        source=1;
        bellman_ford();
        cout<<dis[n];
    }
    return 0;
}

SPFA 算法 O(kE)

Bellman-Ford算法的队列实现，减少了不必要的冗余计算。

【模板】

int map[101][101],dist[101];
bool visit[101];
int n,m;
void init()//初始化
{
    for(int i=1;i<101;i++)
     for(int j=1;j<101;j++)
      {
            if(i==j)
             map[i][j]=0;
            else 
             map[i][j]=map[j][i]=99999999;
      }
}
void spfa(int start)
{
    queue<int>Q;
    int now;
    memset(visit,false,sizeof(visit));
    for(int i=1;i<=n;i++)
      dist[i]=99999999;
    dist[start]=0;
    Q.push(start);
    visit[start]=true;
    while(!Q.empty())
    {
        now=Q.front();
        Q.pop();
        visit[now]=false;
        for(int i=1;i<=n;i++)
        {
            if(dist[i]>dist[now]+map[now][i])
            {
              dist[i]=dist[now]+map[now][i];
              if(visit[i]==0)
              {
                    Q.push(i);
                    visit[i]=true;
              }
            }
        }
    }
}
}

【例题代码】

#include<iostream>  
#include<cstdio>
#include<cstring>  
#include<queue>  
using namespace std;  
int map[101][101],dist[101];
bool visit[101];
int n,m;
void init()
{
    for(int i=1;i<101;i++)
     for(int j=1;j<101;j++)
      {
            if(i==j)
             map[i][j]=0;
            else 
             map[i][j]=map[j][i]=99999999;
      }
}
void spfa(int start)
{
    queue<int>Q;
    int now;
    memset(visit,false,sizeof(visit));
    for(int i=1;i<=n;i++)
      dist[i]=99999999;
    dist[start]=0;
    Q.push(start);
    visit[start]=true;
    while(!Q.empty())
    {
        now=Q.front();
        Q.pop();
        visit[now]=false;
        for(int i=1;i<=n;i++)
        {
            if(dist[i]>dist[now]+map[now][i])
            {
              dist[i]=dist[now]+map[now][i];
              if(visit[i]==0)
              {
                    Q.push(i);
                    visit[i]=true;
              }
            }
        }
    }
}
int main()
{  
    while(scanf("%d%d",&n,&m)!=EOF)
    {  
        init();  
        while(m--)
        {  
            int a,b,c;  
            scanf("%d%d%d",&a,&b,&c);  
            if(map[a][b] > c)
            {  
                map[a][b]=map[b][a]=c;  
            }  
        }  
        spfa(1);  
        printf("%d\n",dist[n]);  
    }  
    return 0;  
}
风凌残度
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路径算法问题
m0_63067791的博客
01-23 837
题目: 给出一张包含n个节点、m条边的无向图（无重边，无自环），请你求出图上两点s,t间的最短路径长度。 其中1<=n<=500，1<=m<=10000，1<=任意边权<=500000； Input 第一行两个数n,m，分别表示节点数和边数，以空格隔开； 之后m行，每行3个数u,v,w[i]，表示点u和v间有一条权值为w[i]的边； 最后一行，两个数s,t表示选择的两个点，以空格隔开。 Output 输出一个数，表示s,t间最短路径的长度。 Sample
n个点 最短路径
my dream is possible
06-06 2989
Problem B Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total Submission(s) : 2   Accepted Submission(s) : 1 Problem Description Eddy begins to like painting
最短路径算法
yanxiaoqi931的博客
07-14 319
首先是floyd算法，这种算法可以求出图中任意两点之间的最短距离，但是计算的时间复杂度较高，为O(n^3)。具体实现思路如下： 类似于动态规划，设置动态数组d[k][i][j]，代表着在只允许经过前k个点时，点i到点j之间的最短路径。其中d[k][i][i]全为0，然后输入边长可以赋予给d[0][i][j]。 设置三重循环，对k，i，j进行迭代，每加入一个新的中间点k，那么d[k-1][i][k]+d[k-1][k][j]就是当路径中强行加入点k后的长度，若效果好于前一个最优路径d[k-1][i][j]，
【图论】最短路径
C20181503csy的博客
10-18 536
最短路径问题(floyed.cpp dijkstra.cpp) 题目描述 平面上有n个点(n 输入 第1行：1个整数n 第2..n+1行：每行2个整数x和y，描述了一个点的坐标 第n+2行：1个整数m，表示图中连线的数量 接下来有m行，每行2个整数i和j，表示第i个点和第j个点之间有连线 最后1行：2个整数s和t，分别表示源点和目标点 输出 第1
最短路径问题
Willer_Snow的博客
04-20 521
简单最短路径问题、Floyd算法
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法是图论中的一个经典问题，用于寻找图中两点之间最短的路径。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出的一种解决这一问题的有效方法。本篇文章将深入探讨Dijkstra算法的基本原理、...
最短路径分析.zip_AE最短路径_ae 最短路径_gai_最短流程_最短路径
07-15
在IT领域，最短路径分析是一项关键的技术，广泛应用于网络路由、交通规划、图形算法等多个方面。本资源“最短路径分析.zip”聚焦于利用C#编程语言与Adobe After Effects（AE）进行最短路径的计算和可视化。下面将...
python实现最短路径的实例方法
01-19
最短路径问题（python实现） 解决最短路径问题：（如下三种算法） （1）迪杰斯特拉算法（Dijkstra算法） （2）弗洛伊德算法（Floyd算法） （3）SPFA算法 第一种算法： Dijkstra算法 广度优先搜索解决赋权有向图或者...
最短路径_路径_matlab求最短路径_复杂网络_
09-29
在IT领域，尤其是在网络分析和图论中，计算最短路径是一个常见的问题。"最短路径"是指在图中从一个节点到另一个节点的路径，其中路径的长度是边的权重之和，通常是最小的。这个概念在路由算法、交通规划、社交网络...
c语言算法与数据结构最短路径报告+代码.zip
08-06
这份"C语言算法与数据结构最短路径报告+代码"压缩包，显然是为了帮助初学者理解和应用这些概念。以下是对其中涉及的主要知识点的详细阐述： 1. **C语言**：C语言是一种强大的、低级的编程语言，广泛用于系统编程、...
编写算法，由依次输入的顶点数目、狐的数目、各顶点的信息和各条狐的信息建立有向图的邻接表
11-24
我做这个作业的时候发现没有可以参考的代码，于是把自己写的发出来咯。这是一个完整的程序，包括结构定义、初始化存储空间、构造邻接表和输入控制
最短路径问题------Dijkstra算法（学习笔记）
Prince的博客
07-22 448
最短路径问题------Dijkstra算法（学习笔记） 算法思想： 选取一个点作为起点 遍历其他与起点构成通路的点，搜寻权值最小的道路，然后把这个点与起点连接，更新标记，更新其他点到起点的权值；接着遍历除了已选道路之外的点，进行，… … ，遍历仍然是n-1次（和最小生成树很像）。 Dijkstra算法和最小生成树中的Prim算法的主要区别： Dijkstra算法中，要保存每个点到起点的总权值； 而在Prim算法中，保存的是每个点到最小生成树的权值 其他的步骤类似 例题 HDU 2544 ---- 最短路
c++ 第七次上机实验
zenglin11的博客
06-05 262
一、问题及代码 /* * 文件名称： c++第七次实验 * 作 者： 曾林 * 完成日期： 2016 年 6 月 4 日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分:略 * 输入描述： 无 * 问题描述： 略 * 程序输出： 略 * 问题分析： 略 * 算法设计： 无 */ #include using nam
数据结构第七次上机试验——最短路径
HPU_LY的博客
11-13 2795
实验内容与要求：        根据输入的图形，输入起点和终点，求出最短路径和最短路径的长度。 具体步骤：        1. 编写一段代码，接收键盘的输入定点的数量，并以输入的整数作为边来建立图形的邻接矩阵（无向权重图）。            例如：5 6 12             表示顶点5和顶点6之间有边，边的权重为12        2. 打印出邻接矩阵。       ...
数据结构篇之最短路径
HPU_FRDHR的博客
11-13 1069
————————————最短路径———————————— 问题抽象：在带权有向图中A点（源点）到达B点（终点）的多条路径中，寻找一条各边权值之和最小的路径，即最短路径。 两种常见的最短路径问题： 一、 单源最短路径—用Dijkstra（迪杰斯特拉）算法 二、所有顶点间的最短路径—用Floyd（弗洛伊德）算法 Dijkstra算法思想 ① 初始化： ●  将源点v0加到S中，即S[...
数据结构—dijkstra
Acer12138的博客
11-13 435
实验七 最短路径 2018 年 11 月 13 日 实验内容与要求 根据输入的图形，输入起点和终点，求出最短路径和最短路径的 长度。 具体步骤 编写一段代码，接收键盘的输入定点的数量，并以输入的整数对作为边来建 立图形的邻接矩阵（无向权重图） 。 例如 ： 5，6，12 表示定点 5 和定点 6 间有边，边的权重为 12。 打印出邻接矩阵。 输入起点和终点。 打印最短路径和最短路径的长度 样例：...
数据结构——图的邻接矩阵法实现代码
Miss Z的博客
09-09 4306
不带权无向图 #include<stdio.h> #define MaxVertenNum 6 //顶点数目的最大值 typedef char VertexType; //顶点的数据类型 typedef int EdgeType; //存放顶点信息 typedef struct { VertexType Vex[MaxVertenNum]; //顶点表 EdgeType Edge[MaxVertenNum][MaxVertenNum]; //邻接矩阵 int vexnum, edgenum
NEFU OJ 207 最短路径问题
ACM,再见！
02-11 2093
http://acm.nefu.edu.cn/JudgeOnline/contestshow.php?contest_id=120&problem_id=207&num=2 description 有n个站，求从1站到n站的最短路线。 input 输入第一行n和m, n表示有n个站，m表示有m条道路，(n
优化算法：从单源最短路径到多源最短路径
"这篇文章除了介绍MapX在最短路径算法中的应用，还讨论了不同的算法在解决最短路径问题上的效率和适用场景。文章提到了Floyd算法、宽度优先搜索（BFS）以及Dijkstra算法。Floyd算法虽然能解决所有点对之间的最短路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值