Bellman-ford:

/*
bellman ford
*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
const int Max = 9999;
typedef struct edge{
int from,to;
int ed;
}Edge;
Edge edge[100];
int v[Max];
int d[Max];
int V,E;
void bellman_ford(int s)
{
memset(d,0x3f,sizeof(d));
d[s]=0;
while(true){//如果不存在负圈,最多执行|V|-1次
bool update = false;
for(int i=0;i<E;i++){
Edge e = edge[i];
if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.ed){
d[e.to]=d[e.from]+e.ed;
update = true;
}
}
if(!update) break;
}
}
bool find_negative_loop()
{
memset(d,0,sizeof(d));
for(int i=0;i<V;i++)
for(int j=0;j<E;j++){
Edge e = edge[j];
if(d[e.to]>d[e.from]+e.ed){
d[e.to] = d[e.from]+e.ed;
if(i==V-1) return true;
}
}
return false;
}
int main()
{
int s,e;
scanf("%d%d",&V,&E);
for(int i=0;i<V;i++)
scanf("%d",&v[i]);
for(int i=0;i<E;i++)
scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].ed);
if(find_negative_loop()) printf("yes\n");
else printf("no\n");
return 0;
}

floyd-warshall:

/*
floyd-warshall
*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
const int Max = 200; int d[Max][Max];
int V,E;
bool floyd_warshall()
{
for(int k=1;k<=V;k++){
for(int i=1;i<=V;i++){
for(int j=1;j<=V;j++){
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
for(int i=1;i<=V;i++)
if(d[i][i]<0){
return false;
}
return true;
}
int main()
{
freopen("input.txt","r",stdin);
scanf("%d%d",&V,&E);
for(int i=1;i<=V;i++)
for(int j=1;j<=V;j++)
d[i][j]=d[j][i] = (i==j?0:INF);
for(int i=0;i<E;i++)
{
int from,to,cost;
scanf("%d%d%d",&from,&to,&cost);
d[from][to]=d[to][from]=cost;
} if(floyd_warshall()) printf("%d\n",d[1][V]);
else printf("负圈\n");
return 0;
}

dijkstra:

邻接矩阵实现

/*
dijkstra1
*/
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std; const int Max = 200;
const int INF = 0x3f3f3f3f;
int d[Max];
int vis[Max];
int cost[Max][Max];
int V,E; void dijkstra(int s)
{
memset(d,0x3f,sizeof(d));
memset(vis,0,sizeof(vis));
d[s]=0;
while(1){
int v = -1;
for(int u=1;u<=V;u++){
if(!vis[u]&&(v==-1||d[u]<d[v]))
v = u;
}
if(v==-1) break;
vis[v]=1;
for(int u=1;u<=V;u++){
d[u]=min(d[u],d[v]+cost[v][u]);
}
}
}
int main()
{
//freopen("input.txt","r",stdin);
int from,to,co;
cin>>V>>E;
for(int i=1;i<=V;i++)
for(int j=1;j<=V;j++)
cost[i][j]=INF; for(int i=0;i<E;i++)
{
cin>>from>>to;
cin>>cost[from][to];
}
int s,en;
cin>>s>>en;
dijkstra(s);
cout<<d[en]<<endl;
return 0;
}
void dijkstra()
{
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
dis[1]=0;
for(int i=1;i<=V;i++)
{
int mi = INF,k;
for(int j=1;j<=V;j++){
if(vis[j]==0&&dis[j]<mi){
mi = dis[j];
k = j;
}
}//找最小
vis[k]=1;
for(int j=1;j<=V;j++)
dis[j]=min(dis[j],dis[k]+mp[k][j]);
}
}

优先队列实现:

/*
dijkstra2
*/
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
const int Max = 200;
typedef pair<int,int> P;
typedef struct Edge{
int v,cost;
};
Edge edge[Max];
vector<Edge> G[Max];
int d[Max];
int V,E; void dijkstra(int s)
{
memset(d,0x3f,sizeof(d));
d[s]=0;
priority_queue<P ,vector<P>,greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P top = que.top();que.pop();
int u = top.second;
if(d[u]<top.first) continue; for(int i=0;i<G[u].size();i++){
Edge e = G[u][i];
if(d[e.v]>d[u]+e.cost){
d[e.v]=d[u]+e.cost;
que.push(P(d[e.v],e.v));
}
}
} }
int main()
{
cin>>V>>E;
for(int i=0;i<E;i++){
int u;
cin>>u>>edge[i].v>>edge[i].cost;
G[u].push_back(edge[i]);
}
int s,e;
cin>>s>>e;
dijkstra(s);
printf("s->e:%d\n",d[e]);
return 0;
}

路径还原:

            memset(pre,-1,sizeof(pre));
…………………………
pre[v]=now;
…………………………
vector<int> path;
int tmp = t;
while(tmp!=-1){
path.push_back(tmp);
tmp = pre[tmp];
}
for(int i=path.size()-1;i>=0;i--)
if(i==0) printf("%d ",path[i]);
else printf("%d -> ",path[i]);

最短路 模板 【bellman-ford,dijkstra,floyd-warshall】的更多相关文章

  1. 最短路模板|堆优化Dijkstra,SPFA,floyd

    Ⅰ:Dijkstra单源点最短路 1.1Dijkstra const int MAX_N = 10000; const int MAX_M = 100000; const int inf = 0x3f ...

  2. 关于SPFA Bellman-Ford Dijkstra Floyd BFS最短路的共同点与区别

    关于模板什么的还有算法的具体介绍 戳我 这里我们只做所有最短路的具体分析. 那么同是求解最短路,这些算法到底有什么区别和联系: 对于BFS来说,他没有松弛操作,他的理论思想是从每一点做树形便利,那么时 ...

  3. 最短路问题(Bellman/Dijkstra/Floyd)

    最短路问题(Bellman/Dijkstra/Floyd) 寒假了,继续学习停滞了许久的算法.接着从图论开始看起,之前觉得超级难的最短路问题,经过两天的苦读,终于算是有所收获.把自己的理解记录下来,可 ...

  4. ACM-最短路(SPFA,Dijkstra,Floyd)之最短路——hdu2544

    ***************************************转载请注明出处:http://blog.csdn.net/lttree************************** ...

  5. 图论之最短路径(1)——Floyd Warshall & Dijkstra算法

    开始图论学习的第二部分:最短路径. 由于知识储备还不充足,暂时不使用邻接表的方法来计算. 最短路径主要分为两部分:多源最短路径和单源最短路径问题 多源最短路径: 介绍最简单的Floyd Warshal ...

  6. ACM/ICPC 之 最短路径-Bellman Ford范例(POJ1556-POJ2240)

    两道Bellman Ford解最短路的范例,Bellman Ford只是一种最短路的方法,两道都可以用dijkstra, SPFA做. Bellman Ford解法是将每条边遍历一次,遍历一次所有边可 ...

  7. POJ-图论-最短路模板(邻接矩阵)

    POJ-图论-最短路模板 一.Floyd算法 刚读入数据时,G为读入的图邻接矩阵,更新后,G[i][j]表示结点i到结点j的最短路径长度 int G[N][N];//二维数组,其初始值即为该图的邻接矩 ...

  8. 最短路径-Dijkstra+Floyd+Spfa

    Dijkstra算法: Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止.Dijkstra ...

  9. poj1511/zoj2008 Invitation Cards(最短路模板题)

    转载请注明出处: http://www.cnblogs.com/fraud/          ——by fraud Invitation Cards Time Limit: 5 Seconds    ...

随机推荐

  1. IIS站点工作原理与ASP.NET工作原理

    IIS站点工作原理与ASP.NET工作原理  一.IIS IIS 7.0工作原理图 两种模式: 1.用户模式(User Mode)(运行用户的程序代码.限制在特定的范围内活动.有些操作必须要受到Ker ...

  2. Phong和Blinn-Phong光照模型

    Phong和Blinn-Phong是计算镜面反射光的两种光照模型,两者仅仅有很小的不同之处. 1.Phong模型 Phone模型计算中的一个关键步骤就是反射向量R的计算: 上图中的位于表面“下面”的向 ...

  3. 如何快速学好Shell脚本?

    Shell 语言作为类 Unix 系统的原生脚本,有着非常实用的价值.但对于很多刚刚接触 Shell 脚本的同学来说,搞懂 Shell 语言的语法却是一件非常困难的事情.甚至有人吐槽,或许没有谁能清楚 ...

  4. MyBatis Generator介绍

    MyBatis Generator介绍 MyBatis Generator (MBG) 是一个Mybatis的代码生成器 MyBatis 和 iBATIS. 他可以生成Mybatis各个版本的代码,和 ...

  5. Java,JavaScript,jQuery,jSP,js

    js是javascript文件的文件后缀,就像 a.txt 这个.txt是后缀一样 jsp是jsp网页文件的后缀,而jsp是java web 的表现层的一种技术 jquery 是一个函数库,基于jav ...

  6. 连接db2数据库出现No buffer space available (maximum connections reached?)

    Caused by: javax.naming.NamingException: [jcc][t4][2043][11550][3.57.82] 异常 java.net.SocketException ...

  7. python之排列组合测试

    # test permutations and combinations import itertools as it for i in it.combinations('abcd',2): prin ...

  8. spring学习 八 面向切面编程(AOP)概述

    注:本文大部分参考   --------------------- 本文来自 -望远- 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/yanquan345/artic ...

  9. ServiceDesk Plus解析内容,简化工单管理

  10. 组合数C(n,m)的四种求解方法

    转自:文章 1.暴力求解 C(n,m)=n*(n-1)*...*(n-m+1)/m!,(n<=15): int CF(int n,int m) { ,i,j; ;i--) ans*=i; ;i- ...