以下代码都是自己敲的，结合acwing和算法笔记的一些思路整理。禁止盗用！
有些模板算法是acwing的 做了标记。
一、朴素Dijkstra算法
整体思想：
1.找到与起点s最近的且未确认最短路径的顶点(记为u)，访问并加入集合st(确定了最短路的集合)。
2.之后，令u为中介点，优化起点s与所有经过u可以到达的顶点v的最短距离。
算法模板：
//朴素Dijkstra 邻接矩阵存储稠密图
int g[N][N];//g[a][b]:a->b的权重
int dist[N];//dist[i]:起点到i的距离
bool st[N];//st[i]:i点是否已确定最短路
void dijkstra(int u)//u为起点
{
memset(dist,0x3f,sizeof dist);//距离都初始化为很大的数
dist[u]=0;//u->u 距离为0 起点为0
for(int i=0;i<n;i++)//n个点 n次循环
{
int t=-1;//t是距离最近的未确定最短路点的编号
for(int j=1;j<=n;j++)//遍历n个点
if(!st[j] && (t==-1 || dist[t]>dist[j]))//寻找最近的点
t=j;
st[t]=true;//找到的点 确定了最短路
for(int j=1;j<=n;j++)//遍历n个点 用最新的点更新迭代所有出边
dist[j]=min(dist[j],dist[t]+g[t][j]);
}
}
算法题目：
849. Dijkstra求最短路 I - AcWing题库
#include<iostream> #include<cstring> using namespace std; const int N=510; int g[N][N],dist[N]; bool st[N]; int n,m; void dijkstra(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; for(int i=0;i<n;i++) { int t=-1; for(int j=1;j<=n;j++) if(!st[j] && (t==-1 || dist[t]>dist[j])) t=j; st[t]=true; for(int j=1;j<=n;j++) dist[j]=min(dist[j],dist[t]+g[t][j]); } } int main() { scanf("%d%d",&n,&m); memset(g,0x3f,sizeof g); while(m--) { int a,b,w; scanf("%d%d%d",&a,&b,&w); g[a][b]=min(g[a][b],w); } dijkstra(1); if(dist[n]==0x3f3f3f3f) printf("-1\n"); else printf("%d\n",dist[n]); return 0; }
算法笔记—P368 例题 亚历山大灭六国
#include<iostream> #include<cstring> using namespace std; const int N=1000; int g[N][N],dist[N]; bool st[N]; int n,m,k; void dijkstra(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; for(int i=0;i<n;i++) { int t=-1; for(int j=0;j<n;j++) if(!st[j] && (t==-1 || dist[t]>dist[j])) t=j; st[t]=true; for(int j=0;j<n;j++) if(dist[j]>dist[t]+g[t][j]) dist[j]=dist[t]+g[t][j]; } } int main() { memset(g,0x3f,sizeof g); scanf("%d%d%d",&n,&m,&k); for(int i=0;i<m;i++) { int a,b,w; scanf("%d%d%d",&a,&b,&w); g[a][b]=min(g[a][b],w); } dijkstra(k); for(int i=0;i<n;i++) printf("%d ",dist[i]); return 0; }
我们已经求出了最短距离，那么最短路径本身我们应该怎么求呢？
在每一次u作为中间点可以更新其余顶点v的时候，可以用pre数组记录一下。（s->…->u->v）
int pre[N];//最短路径
//一开始将前驱都指向自己
for(int i=1;i<=n;i++) pre[i]=i;
//更新同时求最短路径
for(int j=1;j<=n;j++)
if(dist[j]>dist[t]+g[t][j])
{
dist[j]=dist[t]+g[t][j];
pre[j]=t;
}
但是平时比赛中，dijkstra不会就单纯考最短路径长度，或者，最短路径有多条，会增加一个第二标尺（第一标尺是距离）。第二标尺常见的是以下三种出题方法或其组合。
其实就只需要增加一个数组来存放新的数据，然后再优化dist[i]的时候增加修改即可。
1、给每条边再增加一个边权（比如说花费），要求在最短路径多条时要求路径上花费之和最小（其他含义的话也可能是最大）。
解题方法：cost[u][v]表示u->v的花费（题目给出），并增加一个数组c[ ]，令从起点s到达顶点u的最少花费为c[u]，初始时只有c[s]=0，其余都最大。这样就可在优化dist时，如果路径相同，取花费更少的为最优解。
int cost[N][N],c[N];//cost[a][b]:a->b的花费 c[i]：起点到i点的最少花费
memset(c,0x3f,sizeof c);
ct[u]=0; //u->u 不要花钱
for(int j=1;j<=n;j++)//遍历n个点 用最新的点更新迭代所有出边
if(dist[j]>dist[t]+g[t][j])
{
dist[j]=dist[t]+g[t][j];//以t为中介点可以使dist[j]更优
c[j]=c[t]+cost[t][j];
}else if(dist[j]==dist[t]+g[t][j] && c[j]>c[t]+cost[t][j])
c[j]=c[t]+cost[t][j];//最短距离相同看是否可以让c[v]更优
2、增加点权（每个城市能收集到物资），在最短路径多条时，要求路径点权之和最大（也可以是最小）。
解题方法:weight[u]表示城市u中的物资数量（题目给出），并增加一个数组w[ ]，令从起点s到达顶点u可以收集到的最大物资为w[u]，初始化时w[s]=weight[s]，其余w[u]=0;更新最短路径时，更新w[u]，如果最短路径长度相同，取最大者。
int weight[N],w[N];//weight[i]:i点的物资 w[i]:起点->i的最大物资量
memset(w,0,sizeof w);//物资初始化为0
w[u]=weight[u];//起点物资
for(int j=1;j<=n;j++)
{
if(dist[j]>dist[t]+g[t][j])
{
dist[j]=dist[t]+g[t][j];
w[j]=w[t]+weight[j];//更新同时更新物资
}
else if(dist[j]==dist[t]+g[t][j] && w[j]<w[t]+weight[j])
w[j]=w[t]+weight[j];//最短路径长度相同，选择物资多的
}
3、求出有多少条最短路径。
解题方案：增加一个数组num[ ]，令从起点s到达顶点u的最短路径条数为num[u]，初始化时num[s]为1，其余num[ ]为0，更新dist[j]时，只需要让num[j]继承num[t]即可，最短距离相同时，要累加。
int num[N];//num[i]: 起点到i的最短路径条数
memset(num,0,sizeof num);//路径为0
num[u]=1;//起点一条路径 自环
for(int j=1;j<=n;j++)
{
if(dist[j]>dist[t]+g[t][j])
{
dist[j]=dist[t]+g[t][j];
num[j]=num[t];//更新同时继承路径条数
}
else if(dist[j]==dist[t]+g[t][j])
num[j]+=num[t];//最短路径长度相同，累加num
}
题目详情 - 1003 Emergency (25 分) (pintia.cn)
//城市互通 无向图！！！！ 一开始看成有向图做的 #include<iostream> #include<cstring> using namespace std; const int N=510; int g[N][N]; int weight[N],w[N],num[N],dist[N]; int n,m,c1,c2; bool st[N]; void dijkstra(int u) { memset(dist,0x3f,sizeof dist); memset(w,0,sizeof w); memset(num,0,sizeof num); w[u]=weight[u]; num[u]=1; dist[u]=0; for(int i=0;i<n;i++) { int t=-1; for(int j=0;j<n;j++) if(!st[j] && (t==-1 || dist[t]>dist[j])) t=j; st[t]=true; for(int j=0;j<n;j++) { if(dist[j]>dist[t]+g[t][j]) { dist[j]=dist[t]+g[t][j]; num[j]=num[t]; w[j]=w[t]+weight[j]; } else if(dist[j]==dist[t]+g[t][j]) { num[j]+=num[t]; if(w[j]<w[t]+weight[j]) w[j]=w[t]+weight[j]; } } } } int main() { scanf("%d%d%d%d",&n,&m,&c1,&c2); memset(g,0x3f,sizeof g); for(int i=0;i<n;i++) scanf("%d",&weight[i]); while(m--) { int a,b,c; scanf("%d%d%d",&a,&b,&c); g[a][b]=g[b][a]=min(g[a][b],c); } dijkstra(c1); printf("%d %d\n",num[c2],w[c2]); return 0; }
题目详情 - 1030 Travel Plan (30 分) (pintia.cn)
#include<iostream> #include<cstring> #include<vector> using namespace std; const int N=510; int n,m,s,d; int g[N][N],dist[N]; int cost[N][N],c[N],pre[N]; bool st[N]; vector<int> path; void dijkstra(int u) { memset(dist,0x3f,sizeof dist); memset(c,0x3f,sizeof c); dist[u]=0; c[u]=0; for(int i=0;i<n;i++) pre[i]=i; for(int i=0;i<n;i++) { int t=-1; for(int j=0;j<n;j++) if(!st[j] && (t==-1 || dist[t]>dist[j])) t=j; st[t]=true; for(int j=0;j<n;j++) { if(dist[j]>dist[t]+g[t][j]) { dist[j]=dist[t]+g[t][j]; pre[j]=t; c[j]=c[t]+cost[t][j]; } else if(dist[j]==dist[t]+g[t][j] && c[j]>c[t]+cost[t][j]) { c[j]=c[t]+cost[t][j]; pre[j]=t; } } } } int main() { scanf("%d%d%d%d",&n,&m,&s,&d); memset(g,0x3f,sizeof g); while(m--) { int a,b,dis,c; scanf("%d%d%d%d",&a,&b,&dis,&c); if(g[a][b]>dis) { g[a][b]=g[b][a]=dis; cost[a][b]=cost[b][a]=c; } } dijkstra(s); int t=d; while(t!=s) { path.push_back(t); t=pre[t]; } path.push_back(s); for(int i=path.size()-1;i>=0;i--) printf("%d ",path[i]); printf("%d %d",dist[d],c[d]); return 0; }
二、堆优化Dijkstra
整体思想：堆优化，就是将寻找最近的未确定的点的时间复杂度变为O(1)。用邻接表来存储稀疏图，用优先队列来放堆。每次取出堆顶，然后去更新堆顶的所有出边，更新过的放入队列中。
//堆优化Dijkstra
typedef pair<int,int> PII;
int n;//点数
int h[N],w[N],e[N],ne[N],idx;//邻接表的存储 w边的权重
int dist[N];
bool st[N];
void dijkstra(int u)
{
memset(dist,0x3f,sizeof dist);
dist[u]=0;
priority_queue<PII,vector<PII>,greater<PII>> heap;
heap.push({0,u});
while(heap.size())//堆不空
{
auto t=heap.top();//取出堆顶
heap.pop();
int ver=t.second,distance=t.first;
if(st[ver]) continue;
//一个点可能有多个点到达，但是如果已确认最短路径，就不需要后续再去冗余
st[ver]=true;//堆顶元素 最短路径已确定
for(int i=h[ver];i!=-1;i=ne[i])//遍历所有出边
{
int j=e[ver];
if(dis[j]>dis[ver]+w[i])//更新距离
{
dis[j]=distance+w[i];
heap.push({dist[j],j});//放入堆中
}
}
}
}
850. Dijkstra求最短路 II - AcWing题库
#include<iostream> #include<cstring> #include<queue> using namespace std; typedef pair<int,int> PII; const int N=1.5e5+10; int n,m; int h[N],w[N],ne[N],idx,e[N]; int dist[N]; bool st[N]; void add(int a,int b,int c) { e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++; } void dijkstra(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; priority_queue<PII,vector<PII>,greater<PII>> heap; heap.push({0,u}); while(heap.size()) { auto t=heap.top(); heap.pop(); int ver=t.second,distance=t.first; if(st[ver]) continue; st[ver]=true; for(int i=h[ver];i!=-1;i=ne[i]) { int j=e[i]; if(dist[j]>distance+w[i]) { dist[j]=distance+w[i]; heap.push({dist[j],j}); } } } } int main() { scanf("%d%d",&n,&m); memset(h,-1,sizeof h); while(m--) { int a,b,c; scanf("%d%d%d",&a,&b,&c); add(a,b,c); } dijkstra(1); if(dist[n]==0x3f3f3f3f) printf("-1\n"); else printf("%d\n",dist[n]); return 0; }
三、Bellman_Ford算法
整体思想：两层循环，外层循环k次（k条边），内层每次遍历所有的边，并进行更新迭代。
如果外层循环第n次还有更新的话，说明存在负权回路，因为n条边，至少有n+1个点，题目中只有n个点，那么必定有两个点是相同的，那么一定存在回路。
//Bellman_Ford acwing
int n,m;
int dist[N];
struct edge{
int a,b,w;
}edge[M];//a->b的权重w
int Bellman_ford(int u)
{
memset(dist,0x3f,sizeof dist);
dist[u]=0;
for(int i=0;i<n;i++)//经过i条边
{
for(int j=0;j<m;j++)//遍历每一个边
{
auto e=edge[j];
dist[e.b]=min(dist[e.b],dist[e.a]+e.w);//更新迭代
}
}
if(dist[n]>0x3f3f3f3f/2) return -1;
else return dist[n];
}算法笔记Bellman_Ford算法模板
//算法笔记模板 int n,m; int dist[N]; struct edge{ int a,b,w; }edge[M];//a->b的权重w bool Bellman_ford(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; for(int i=0;i<n-1;i++)//n个点 最多n-1条边 所以经过n-1次循环 { for(int j=0;j<m;j++)//遍历每一个边 { auto e=edge[j]; dist[e.b]=min(dist[e.b],dist[e.a]+e.w);//更新迭代 } } //第n次循环 for(int j=0;j<m;j++)//遍历每一个边 { auto e=edge[j]; if(dist[e.b]>dist[e.a]+e.w))//如果还可以被松弛 return false;//说明图中有源点可达的负环 } return true; }
#include<iostream> #include<cstring> using namespace std; const int N=510,M=10010; int dist[N],n,m,k,backup[N];//backup 防止内循环遍历边的时候 发生串联 struct edge{ int a,b,w; }edge[M]; void Bellman_ford(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; for(int i=0;i<k;i++) { memcpy(backup,dist,sizeof dist); for(int j=0;j<=m;j++) { auto e=edge[j]; dist[e.b]=min(dist[e.b],backup[e.a]+e.w); } } } int main() { scanf("%d%d%d",&n,&m,&k); for(int i=0;i<m;i++) { int a,b,c; scanf("%d%d%d",&a,&b,&c); edge[i]={a,b,c}; } Bellman_ford(1); if(dist[n]>=0x3f3f3f3f/2) printf("impossible"); // 例如 5号点和n号点 1号点都无法到达 但是在内循环 遍历边的时候 可能5号点就把n号点给更新了 else printf("%d\n",dist[n]); return 0; }
四、SPFA算法
整体思想：Bellman_Ford算法每一次外层循环都需要，遍历所有的边，会有大量无意义的操作，我们可以用邻接表，存储每一个点的出边，将内存循环遍历所有边改成遍历所有出边。并且将更改的点放入队列中（只有点更改了，他的出边才有可能更改）。
SPFA模板-acwing
int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 bool st[N]; // 存储每个点是否在队列中 // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1 int spfa() { memset(dist, 0x3f, sizeof dist); dist[1] = 0; queue<int> q; q.push(1); st[1] = true; while (q.size()) { auto t = q.front(); q.pop(); st[t] = false; for (int i = h[t]; i != -1; i = ne[i]) { int j = e[i]; if (dist[j] > dist[t] + w[i]) { dist[j] = dist[t] + w[i]; if (!st[j]) // 如果队列中已存在j，则不需要将j重复插入 { q.push(j); st[j] = true; } } } } if (dist[n] == 0x3f3f3f3f) return -1; return dist[n]; }
//spfa 运用队列优化Bellman_Ford算法 发生距离更改的就入队 直到队空 #include<iostream> #include<cstring> #include<queue> using namespace std; const int N=1e5+10; int h[N],ne[N],e[N],w[N],idx; int n,m; int dist[N]; bool st[N]; void add(int a,int b,int c) { e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++; } void spfa(int u) { memset(dist,0x3f,sizeof dist); dist[u]=0; queue<int> q; q.push(u); st[u]=true;//st[]防止重复放入队列 true 在队列中不需要在放入 while(q.size()) { int t=q.front(); q.pop(); st[t]=false; for(int i=h[t];i!=-1;i=ne[i]) { int j=e[i]; if(dist[j]>dist[t]+w[i]) { dist[j]=dist[t]+w[i]; if(!st[j]) { q.push(j); st[j]=true; } } } } } int main() { scanf("%d%d",&n,&m); memset(h,-1,sizeof h); for(int i=0;i<m;i++) { int a,b,c; scanf("%d%d%d",&a,&b,&c); add(a,b,c); } spfa(1); if(dist[n]>=0x3f3f3f3f/2) printf("impossible\n"); else printf("%d\n",dist[n]); return 0; }
五、SPFA算法判断是否存在环！
如果点的边数>=点数，那么一定存在回环。
原因：抽屉原理，如果有n条边，那么至少有n+1个点，题目中只有n个点，那么必定有两个点相同，那么一定会存在环。
其实就是用cnt数组来存储边数，然后对边数更新，判断。
//ACwing SPFA模板
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
// 不需要初始化dist数组
// 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
queue<int> q;
//题目问存在负环 并没有说从具体某个点出发存在负环，所以把所有点都放到队列中
for (int i = 1; i <= n; i ++ )
{
q.push(i);
st[i] = true;
}
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}#include<iostream> #include<cstring> #include<queue> using namespace std; const int N=1e6+10; int h[N],ne[N],w[N],idx,e[N];//w[i] i点的权值 int n,m; int dis[N],cnt[N];//dis[i] 1->i 的长度 cnt[] 边数 bool st[N];//st[i] i点是否访问 void add(int a,int b,int c) { e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++; } bool spfa() { queue<int> q; for(int i=1;i<=n;i++) { q.push(i); st[i]=true; } while(q.size())//队列不空 { int t=q.front(); q.pop(); st[t]=false; for(int i=h[t];i!=-1;i=ne[i])//遍历所有出边 { int j=e[i]; if(dis[j]>dis[t]+w[i])//更新 { dis[j]=dis[t]+w[i]; cnt[j]=cnt[t]+1; if(cnt[j]>=n) return true;//边数大于点数 一定存在回环 if(!st[j])//点放入队列 { q.push(j); st[j]=true; } } } } return false; } int main() { scanf("%d%d",&n,&m); memset(h,-1,sizeof h); while(m--) { int a,b,c; scanf("%d%d%d",&a,&b,&c); add(a,b,c); } if(spfa()) puts("Yes"); else puts("No"); return 0; }
六、Floyd算法
整体思想：如果存在顶点k，使得k作为中介点时，顶点i和顶点j的当前最短距离缩短。
三层循环，最外层时枚举终结点k，里层循环分别i，j。
初始化：
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。#include<iostream> using namespace std; const int N=210,INF=1e9; int n,m,Q; int d[N][N]; void floyd() { for(int k=1;k<=n;k++)//k循环中介点 for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) d[i][j]=min(d[i][j],d[i][k]+d[k][j]); } int main() { scanf("%d%d%d",&n,&m,&Q); for(int i=1;i<=n;i++)//初始化d[i][j] i->j的长度 for(int j=1;j<=n;j++) if(i==j) d[i][j]=0; else d[i][j]=INF; for(int i=0;i<m;i++) { int a,b,c; scanf("%d%d%d",&a,&b,&c); d[a][b]=min(d[a][b],c); } floyd(); while(Q--) { int x,y; scanf("%d%d",&x,&y); if(d[x][y]>=INF/2) puts("impossible"); else printf("%d\n",d[x][y]); } return 0; }
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
