各种最短路模板

最新推荐文章于 2021-06-05 17:57:17 发布
最新推荐文章于 2021-06-05 17:57:17 发布
阅读量335 收藏
点赞数
文章标签： 最短路

 原创 http://blog.csdn.net/shuangde800 ， By   D_Double  (转载请标明)


原创大佬的代码格式不是我喜欢的风格...所以都被我稍作修改了下...


1.    Dijkstra  普通版

#include<stdio.h>
#include<string.h>
const int N=105, INF=9999999;
int d[N], w[N][N],vis[N],n,m;
void Dijkstra(int src)
{
	int i,j,u,tmp;
    for(i=1;i<=n;i++)
    d[i]=INF;
    d[src]=0; 
    memset(vis, 0, sizeof(vis));
    for(i=1;i<=n;i++)
	{
        u=-1;
        for(j=1;j<=n;j++)
        {
        	if(!vis[j])
			{
	            if(u==-1||d[j]<d[u]) 
				u=j;
        	}
        }			
        vis[u]=1;
        for(j=1;j<=n;j++)
        {
        	if(!vis[j])
			{
            	tmp=d[u]+w[u][j];
            	if(tmp<d[j]) 
				d[j] = tmp;
        	}
        }			
    }
}
int main()
{
    int a,b,c,i,j;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        for(i=1;i<=n;i++)
		{
            w[i][i]=INF;
            for(j=i+1;j<=n;j++)
            w[i][j]=w[j][i]=INF;
        }
        for(i=0;i<m;i++)
		{
            scanf("%d%d%d",&a,&b,&c);
            w[a][b]=w[b][a]=c;
        }
        Dijkstra(1);
        printf("%d\n",d[n]);
    }
    return 0;
}

2. Dijkstra+邻接表(用数组实现)+优先队列优化

#include<cstdio>
#include<cstring>
#include<utility>
#include<queue>
using namespace std;
const int N=20005;
const int INF=9999999;
typedef pair<int,int>pii;
priority_queue<pii, vector<pii>, greater<pii> >q;
int d[N], first[N], u[N], v[N], w[N], next[N],n,m;
bool vis[N];
// 无向图的输入，注意每输入的一条边要看作是两条边
void read_graph()
{
    memset(first,-1,sizeof(first)); //初始化表头
    for(int e=1;e<=m;e++)
	{
        scanf("%d%d%d",&u[e],&v[e],&w[e]);
        u[e+m]=v[e];
		v[e+m]=u[e]; 
		w[e+m]=w[e];  // 增加一条它的反向边       
        next[e]=first[u[e]];  // 插入链表
        first[u[e]]=e;
        next[e+m]=first[u[e+m]]; // 反向边插入链表
        first[u[e+m]]=e+m;
    }
}
void Dijkstra(int src)
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) 
	d[i]=INF;
    d[src]=0;
    q.push(make_pair(d[src],src));
    while(!q.empty())
	{
        pii u=q.top(); 
		q.pop();
        int x = u.second;
        if(vis[x]) continue;
        vis[x]=true;
        for(int e=first[x];e!=-1;e=next[e])
        {
        	if(d[v[e]]>d[x]+w[e])
			{
	            d[v[e]]=d[x]+w[e];
	            q.push(make_pair(d[v[e]],v[e]));
       	 	} 
        }			
    }
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        read_graph();
        Dijkstra(1);
        printf("%d\n",d[n]);
    }
    return 0;
}


3. Dijkstra+邻接表(用vecor实现)+优先队列优化 

#include<cstdio>
#include<cstring>
#include<utility>
#include<queue>
#include<vector>
using namespace std;
const int N=105;
const int INF=9999999;
typedef pair<int,int>pii;
vector<pii>G[N];
priority_queue<pii, vector<pii>, greater<pii> >q;
int d[N], first[N], u[N], v[N], w[N], next[N],n,m;
bool vis[N];
// 无向图的输入，注意没输入的一条边要看作是两条边
void read_graph()
{
	int a,b,c,i;
    for(i=1; i<=n;i++)
    G[i].clear();   
    for(i=1; i<=m;i++)
	{
        scanf("%d%d%d",&a,&b,&c);
        G[a].push_back(make_pair(b,c));
        G[b].push_back(make_pair(a,c));
    }
}
void Dijkstra(int src)
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) 
	d[i]=INF;
    d[src]=0;
    q.push(make_pair(d[src], src));
    while(!q.empty())
	{
        pii t=q.top(); 
		q.pop();
        int u=t.second;
        if(vis[u]) continue;
        vis[u]=true;
        for(int v=0;v<G[u].size();v++)
        {
       		if(d[G[u][v].first] > d[u]+G[u][v].second)
			{
	            d[G[u][v].first] = d[u]+G[u][v].second;
	            q.push(make_pair(d[G[u][v].first],G[u][v].first));
	        }
        }		
    }
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        read_graph();
        Dijkstra(1);
        printf("%d\n", d[n]);
    }
    return 0;
}

4.Bellman-Ford算法

#include<cstdio>
#include<cstring>
#include<utility>
#include<queue>
using namespace std;
const int N=20005;
const int INF=9999999;
int n, m, u[N],v[N],w[N], d[N];
// 无向图的输入，注意每输入的一条边要看作是两条边
inline void read_graph()
{
    for(int e=1;e<=m;e++)
    scanf("%d%d%d",&u[e],&v[e],&w[e]);
}
inline void Bellman_Ford(int src)
{
    for(int i=1;i<=n;i++) 
	d[i]=INF;
    d[src]=0;
    for(int k=0;k<n-1;k++)
	{
        for(int i=1;i<=m;i++)
		{ 
            int x=u[i],y=v[i];
            if(d[x]<INF)
			{
                if(d[y]>d[x]+w[i])
                d[y]=d[x]+w[i];
            }
            if(d[y]<INF)
			{
                if(d[x]>d[y]+w[i])
                d[x]=d[y]+w[i];
            }
        }
    }
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        read_graph();
        Bellman_Ford(1);
        printf("%d\n", d[n]);
    }
    return 0;
}

5.SPFA

#include<cstdio>
#include<cstring>
#include<utility>
#include<queue>
using namespace std;
const int N=20005;
const int INF=2147483646>>1;
int n, m, first[N],next[N],u[N],v[N],w[N], d[N];
bool vis[N];
queue<int>q;
inline void read_graph()
{
    memset(first, -1, sizeof(first));
    for(int e=1;e<=m;e++)
	{
        scanf("%d%d%d",&u[e],&v[e],&w[e]);
        u[e+m]=v[e],v[e+m]=u[e],w[e+m]=w[e];
        next[e]=first[u[e]];
        first[u[e]]=e;
        next[e+m]=first[u[e+m]];
        first[u[e+m]]=e+m;
    }
}
void SPFA(int src)
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
	d[i]=INF;
    d[src]=0;
    vis[src]=true;
    q.push(src);
    while(!q.empty())
	{
        int x = q.front();  
		q.pop();
        vis[x] = false;
        for(int e=first[x]; e!=-1; e=next[e])
		{
            if(d[x]+w[e] < d[v[e]])
			{
                d[v[e]] = d[x]+w[e];
                if(!vis[v[e]])
				{
                    vis[v[e]] = true;
                    q.push(v[e]);
                }
            }
        }
    } 
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        read_graph();
        SPFA(1);
        printf("%d\n", d[n]);
    }
    return 0;
}

 6.Floyd算法 

#include<cstdio>
#include<cstring>
#include<utility>
#include<queue>
using namespace std;
const int N=105;
const int INF=2147483646;
int n, m, d[N][N];
inline void read_graph()
{
    for(int i=1;i<=n;i++)
	{
        d[i][i]=INF;
        for(int j=i+1;j<=n;j++)
        d[i][j]=d[j][i]=INF;
    }
    int a,b,c;
    for(int e=1;e<=m;e++)
	{
        scanf("%d%d%d",&a,&b,&c);
        d[a][b]=d[b][a]=c;
    }
}
inline void Floyd(int src)
{
    for(int k=1;k<=n;k++)
	{
        for(int i=1;i<=n;i++)
		{
            for(int j=1;j<=n;j++)
            {
            	if(d[i][k]<INF&&d[k][j]<INF)
             	d[i][j]=min(d[i][j], d[i][k]+d[k][j]);
            }                
        }
    }
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m))
	{
		if(n==0&&m==0)break;
        read_graph();
        Floyd(1);
        printf("%d\n", d[1][n]);
    }
    return 0;
}




TheWise_lzy
关注
最短路模板题
及时总结
08-14 424
题目： 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？ Input 输入包括多组数据。每组数据第一行是两个整数N、M（N&amp;lt;=100，M&amp;lt;=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N...
理论： 图论（6）： 单源赋值图最短路径
sun897949163的博客
01-01 742
总括单源最短路径问题在前几篇已经提到过，在这里不再赘述。有额外的一点， 终点和起点都固定的问题称之为：两点之间最短路径问题。 但是因为解决单源最短路径问题的时间复杂度也是一样的， 因此通常当作单源最短路径问题处理（在求单源最短路径的同时求出的实际是单点到全图说有点的最短路径）下面我将讲解最短路径的三种常见算法： Bellman-ford算法 Dijkstra算法 Floyed算法、、Bellman-
最短路 模板题（dijkstra）
smilng的博客
03-23 512
给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。 Input 输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。 (1<n<=1000, 0<m<...
hdoj 2544 最短路 【最短路径模板题】
shengweisong
11-11 1461
最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 33752    Accepted Submission(s): 14662 Problem Description 在每年的校赛里，所有进入决赛的同学都会获
最短路模板（Dijkstra）
HJ
05-08 320
普通版int d[N],vis[N],g[N][N]; int n,m,a,b,len; void Dijkstra(int s) { for(int i=1;i<=n;i++) d[i]=g[s][i]; memset(vis,0,sizeof(vis)); vis[s]=1; for(int i=1;i<=n;i++) { in
最短路算法模板 最短路算法模板
01-25
ACM（国际大学生程序设计竞赛）中，最短路算法是常见的考察点，因此掌握其模板对于参赛者至关重要。这里我们将深入探讨几种常见的最短路算法及其应用。 1. **Floyd-Warshall算法**： 这是一种动态规划方法，适用于...
最短路模板（详细注解）
07-26
在计算机科学领域，尤其是图论和算法设计中，“最短路问题”是一个核心问题，它寻找的是在...通过不断练习，你可以逐渐掌握这些模板，将它们应用到各种实际问题中，从而在竞赛编程、软件开发甚至学术研究中取得成功。
最短路模板合集
繁凡さん的博客
06-03 1606
最短路模板合集
三种最短路模板
算法小猪的博客
02-25 616
一、Floyd算法——只有五行代码的算法 算法思想： 从节点i到节点j的最短路径只有2种可能： 1)直接从节点i到节点j 2)从节点i经过若干个节点k到节点j 假设dis(i,j)为节点i到节点j的最短路径的距离 对于每一个节点k，我们检查dis(i,k)+dis(k,j) < dis(i,j)是否成立， 如果成立，证明从i到k再到j的路径比i直接到j的路径短. 于是dis(...
ACM.algorithm.rar_GCD矩阵_匈牙利_区间匹配_最短路 三维_模板元
09-14
各种算法模板（二分图最大匹配匈牙利算法、最小生成树prime和kruskal算法、Dijkstra算法、两点最短路径负权值边SPFA算法、图任意两点最短路径Floy算法、网络最大流SAP算法、网络最大流最小费用算法、乘法逆元gcd扩展...
各种最短路问题的求解方式
三季人的博客
06-05 279
限制：bellman_ford 和 spfa 可用于判断负环， 其他算法只能用于无负环情况。 朴素dijkstra算法 （ps： 因为时稠密图，我们用邻接矩阵来存图） 设定dist[i]为点i到1的最短距离 st[i]为该点的最短距离是否已经确定 假设我们要求点1到点n的最短距离 先将dist数组初始化为*INF*，*dist[1] = 0*; 循环n次 每次取出所有点中dist最小的点t，并将其标记st[t] = true 通过邻接矩阵用点t来更新其他的点（dist[j] = min(dist[j], .
HDU2544 最短路模板题 Dijkstra
ProboxDu的博客
07-22 377
题目链接 【题意】 图中有N个点，M条边，求1到N的最短时间。保证有解。 N<=100，M<=10000 【分析】 很裸的最短路，但是也好长时间没有打Dijkstra了，而且之前也没有打过+优先队列的，在这里试试，然后WA了好几发。。。。 最后发现优先队列更新的时候d[x]打成了p[i].v 仔细想想，dijkstra本身的思想就是维护两个集合，第一组为已求出最短路径的顶点集合（用S表示
最短路模板
哇哈哈的专栏
03-24 981
一下模板均已通过HDUOJ 2544 程序设计竞赛队空间和时间复杂度要求都很高，所以朴素的Dijkstra算法无论时间还是空间，效率都很低。 所以，一般而言，不带负权的用邻接表建图+堆优化的Dijkstra算法 带负权的的用邻接表建图+SFPA算法 此外，最短路还可以用BFS求，例如边权值都为1的话，就可以用普通队列+BFS求得，边权值不为1，可以用优先队列+BFS求得，这里就不给出实现代
最短路模板。
小菜鸟。。
02-16 280
纯粹是害怕自己忘掉记一遍。 1 Floyd计算多源最短路问题。 void floyd() { for(int i=1;i<=n;++i) //扫一遍中间点 { for(int j=1;j<=n;++j)//扫一遍起点 { for(int k=1;k<=k;++k)//扫一遍所有终点 {
详解最短路算法模板(dijkstra+floyd+spfa)
及时总结
08-13 610
1.Floyd_Warshall算法 参考：《挑战程序设计竞赛》以及 https://blog.csdn.net/Floraqiu/article/details/81483420 核心思路：d[i][j] = min{d[i][j], d[i][k] + d[k][j]} 从i到j有两种路径，经过k点或是不经过k点，所以我们枚举k即可求所有路的最短路。 适用范围：求任意两点间的最短路，...
最短路模板（自用）
洛 水
02-22 218
摘自：https://blog.csdn.net/qq_36932169/article/details/78806863 Floyd算法是多源最短路算法，复杂度最高（n ^ 3），通常用在点比较少的起点不固定的问题中。能解决负边（负权）但不能解决负环。 Dijkstra算法是单源最短路算法，最常用时间复杂度（n ^ 2）优化后可以达到（nlogn），不能解决负边问题，稀疏图需要耗费比较多的空间。...
最短路模板（dijstra）
CoderZ的编程之路
03-10 553
#define INF 0Xfffffff const int Max=1000000; int map[Max][Max]; int dis[Max]; bool vis[Max]; void dijstra() { memset(vis,false,sizeof(vis)); int i,j,mark_num,temp; for(i=1;i<=n;i++) {
多源最短路 c++ floyd 模板
最新发布
06-03
好的，下面是多源最短路的 C++ Floyd 模板： ```cpp #include using namespace std; const int N = 205; const int INF = 0x3f3f3f3f; int n, m; int dis[N][N]; void floyd() { for (int k = 1; k ; k++) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值