[模板]单源最短路径

https://www.luogu.org/problemnew/show/P3371

 1 #include <cstring>
 2 #include <cstdio>
 3 #include <iostream>
 4 #include <queue>
 5 #define lop(i,a,b) for(register int i=a;i<=b;++i)
 6 const int N = 10010, M = 500010, inf = 2147483647;
 7 using namespace std;
 8 const int bufsize = 500000;
 9 char buf[bufsize], *p1, *p2;
10 #define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,bufsize,stdin),p1==p2)?EOF:*p1++)
11
12 inline int read(){
13     register int c = getchar(), f = 1, x = 0;
14     while (!isdigit(c)){if (c == ‘-‘)f = -1; c = getchar();}
15     while (isdigit(c)){x = x * 10 + c - ‘0‘; c = getchar();}
16     return x * f;
17 }
18 int head[N], dis[N], tot, n, m, s, t;bool vis[N];
19 struct Edge{int v, w, next;}G[M];
20 struct Node{
21     int u, w;
22     bool operator<(const Node & rhs) const{
23         return w > rhs.w;
24     }
25 };
26
27 inline void addedge(int u, int v, int w){
28     G[++tot].v=v;G[tot].w=w;G[tot].next=head[u];head[u]=tot;
29 }
30 inline void Dijkstra(int s){
31     //memset(dis,127,sizeof(dis));
32     priority_queue<Node> q;
33     lop(i,1,n)dis[i] = inf;
34     dis[s] = 0;
35     q.push((Node){s,dis[s]});
36     while(!q.empty()){
37         Node x = q.top();q.pop();
38         int u = x.u;
39         if (vis[u]) continue;
40         for(int i = head[u];i;i = G[i].next){
41             int v = G[i].v,w = G[i].w;
42             if (dis[u] + w < dis[v]){
43                 dis[v] = dis[u] + w;
44                 q.push((Node){v, dis[v]});
45             }
46         }
47         vis[u] = 1;
48     }
49 }
50
51 int main(void){
52     n = read(), m = read(), s = read();
53     lop(i,1,m){
54         int u = read(), v = read(), w = read();
55         addedge(u, v, w);
56     }
57     Dijkstra(s);
58     lop(i,1,n)printf("%d ", dis[i]);
59     return 0;
60 }

Dijkstra

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <vector>
 4 #include <queue>
 5 #include <cstring>
 6 using namespace std;
 7 const int N=10005;
 8 const int M=500005;
 9 const int inf=0x7f7f7f7f;
10 struct Node{
11     int v, w;
12 };
13 inline Node Make_Node(int v, int w){
14     Node a; a.v = v; a.w = w;
15     return a;
16 }
17 vector<Node> g[N];
18 int dis[N],n,tot,head[N],inq[N],m,s;
19 queue<int> q;
20
21 inline int read(){
22     int f=1,x=0;char ch;
23     do{ch=getchar();if(ch==‘-‘)f=-1;}while(ch<‘0‘||ch>‘9‘);
24     do{x=x*10+ch-‘0‘;ch=getchar();}while(ch>=‘0‘&&ch<=‘9‘);
25     return f*x;
26 }
27 inline void addedge(int u,int v,int w){
28    g[u].push_back(Make_Node(v, w));
29 }
30 inline void spfa(int s){
31     memset(dis,127,sizeof(dis));dis[s]=0;
32     q.push(s);inq[s]=1;
33     while(!q.empty()){
34         /*int u=q.front();q.pop();inq[u]=0;
35         for(int i=head[u];i;i=G[i].next){
36             int v=G[i].v;
37             if(dis[u]+G[i].w<dis[v]){
38                dis[v]=dis[u]+G[i].w;
39           //  dis[v] = min(dis[v], dis[u] + G[i].w);
40                 if(!inq[v])q.push(v),inq[v]=1;
41             }
42         }*/
43         int u = q.front();q.pop();inq[u] = 0;
44         for(int i = 0; i < g[u].size(); ++i){
45             int v = g[u][i].v, w = g[u][i].w;
46             if (dis[u]+w< dis[v]){
47                 dis[v] = dis[u] + w;
48                 if (!inq[v])q.push(v),inq[v] = 1;
49             }
50         }
51     }
52 }
53 int main(){
54     n=read();m=read();s=read();
55     for(int i=1;i<=m;i++){
56         int u=read(),v=read(),w=read();
57         addedge(u,v,w);
58     }
59     spfa(s);
60     for(int i=1;i<=n;i++)printf("%d%c",dis[i]==inf?2147483647:dis[i],i==n?‘\n‘:‘ ‘);
61     return 0;
62 }

SPFA

原文地址:https://www.cnblogs.com/Ycrpro/p/8452473.html

时间: 2024-08-30 01:10:30

[模板]单源最短路径的相关文章

【洛谷 p3371】模板-单源最短路径(图论)

题目:给出一个有向图,请输出从某一点出发到所有点的最短路径长度. 解法:spfa算法. 1 #include<cstdio> 2 #include<cstdlib> 3 #include<cstring> 4 #include<iostream> 5 #include<queue> 6 using namespace std; 7 typedef long long LL; 8 9 const int N=10010,M=500010; 10 c

[模板]单源最短路径(Dijkstra)

如题,给出一个有向图,请输出从某一点出发到所有点的最短路径长度. 主要还是再打一遍最短路,这种算法我用的不多... 1 #include<bits/stdc++.h> 2 using namespace std; 3 #define ll long long 4 inline int read() 5 { int x=0;bool f=0;char ch=getchar(); 6 while(!isdigit(ch)){ f=(ch==45);ch=getchar();} 7 while(is

P3371 【模板】单源最短路径 如题

P3371 [模板]单源最短路径 时空限制1s / 128MB 题目描述 如题,给出一个有向图,请输出从某一点出发到所有点的最短路径长度. 输入输出格式 输入格式: 第一行包含三个整数N.M.S,分别表示点的个数.有向边的个数.出发点的编号. 接下来M行每行包含三个整数Fi.Gi.Wi,分别表示第i条有向边的出发点.目标点和长度. 输出格式: 一行,包含N个用空格分隔的整数,其中第i个整数表示从点S出发到点i的最短路径长度(若S=i则最短路径长度为0,若从点S无法到达点i,则最短路径长度为214

Luogu 3371【模板】单源最短路径

Luogu 3371[模板]单源最短路径 第一次写博客用图论题来试一试 接下来是正文部分 题目描述 如题,给出一个有向图,请输出从某一点出发到所有点的最短路径长度. 输入输出格式 输入格式: 第一行包含三个整数N.M.S,分别表示点的个数.有向边的个数.出发点的编号. 接下来M行每行包含三个整数Fi.Gi.Wi,分别表示第i条有向边的出发点.目标点和长度. 输出格式: 一行,包含N个用空格分隔的整数,其中第i个整数表示从点S出发到点i的最短路径长度 (若S=i则最短路径长度为0,若从点S无法到达

P3371 【模板】单源最短路径(弱化版)

P3371 [模板]单源最短路径(弱化版) 1 #include<bits/stdc++.h> 2 using namespace std; 3 const int maxn = 10005; 4 struct edge { 5 int v, w; 6 }; 7 vector<edge> maps[maxn]; 8 int dis[maxn]; 9 bool vis[maxn]; 10 int n, m, s; 11 void add(int u, int v, int w) {

单源最短路径Dijkstra、BellmanFord、SPFA【模板】

Dijkstra算法: 将所有点分为两个集合.如果源点s到u的最短路径已经确定,点u就属于集合Va,否则属于集合Vb. 1.将源点s到图中各点的直接距离当做初始值记录为s到各点的最短距离,不能到达的记为INF.S到S距离为0. 2.在集合Vb中的点中找一个点u,使得源点s到该点u路径长度最短,将u从Vb中除去,加到V1中.这时候求出了当前S到u的最短路径. 3.把新确定的点u更新s到集合Vb中每一个点v的距离,如果s到u的距离加上u到v的直接距离小于当前s到v的距离,则表示新找到的最短路径长度比

Dijkstra算法求单源最短路径

1.最短路径 在一个连通图中,从一个顶点到另一个顶点间可能存在多条路径,而每条路径的边数并不一定相同.如果是一个带权图,那么路径长度为路径上各边的权值的总和.两个顶点间路径长度最短的那条路径称为两个顶点间的最短路径,其路径长度称为最短路径长度. 最短路径在实际中有重要的应用价值.如用顶点表示城市,边表示两城市之间的道路,边上的权值表示两城市之间的距离.那么城市A到城市B连通的情况下,哪条路径距离最短呢,这样的问题可以归结为最短路径问题. 求最短路径常见的算法有Dijkstra算法和Floyd算法

单源最短路径(dij+堆优化)

单源最短路径的模板题,感谢同学余能的帮助~ #include<bits/stdc++.h> #define inf 2147483647 using namespace std; bool book [200004]; int cnt=0; int head[200020]; int n,m,qq; struct Edge { int to,next,w; }e[2000005]; struct Dis { int to,w; }dis[20000]; struct cmp1 { bool o

Dijkstra单源最短路径

Dijkstra单源最短路径 给定一个带权有向图G=(V,E) ,其中每条边的权是一个非负实数.另外,还给定 V 中的一个顶点,称为源.现在我们要计算从源到所有其他各顶点的最短路径长度.这里的长度是指路上各边权之和.这个问题通常称为单源最短路径问题. 下面给出两个计算单源最短路径的模板. Dijkstra_简化版:时间复杂度O(n^2),不可处理重边图 //计算图的以s点为起点的单源最短路径 //图中节点从1到n编号 //运行dijkstrea之前,需要先把图中两点间的距离保存在dist[i][