最短路问题
问题
题目描述
如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。
输入格式
第一行包含三个整数 n , m , s n,m,s n,m,s，分别表示点的个数、有向边的个数、出发点的编号。
接下来 m m m 行每行包含三个整数 u , v , w u,v,w u,v,w，表示一条 u → v u \to v u→v 的，长度为 w w w 的边。输出格式
输出一行 n n n 个整数，第 i i i 个表示 s s s 到第 i i i 个点的最短路径，若不能到达则输出 2 31 − 1 2^{31}-1 231−1。
五种图论最短路求法
完整代码扔到文章后面辽（太占地方了
搜索 O ( n m ) O(nm) O(nm)
但是一次只能搜一个起点到终点，对于需要求起点到所有终点的最短路径，
O
(
n
2
m
)
O(n^2m)
O(n2m)势必会T。
上代码
//核心dfs（bfs也能做
void dfs(int t,int ed){
if(dist>dis) return; //剪枝
if(t==ed) {
dis=min(dist,dis); //取最短
return;
}
//前向星遍历
for(int i=head[t];i;i=e[i].next){
int v=e[i].to; //边i的出点
if(vis[v]==0){
vis[v]=1;
dist+=e[i].w;
dfs(v,ed); //递归
dist-=e[i].w;
vis[v]=0;
}
}
}
Floyd O ( n 3 ) O(n^3) O(n3)
Floyd初始化
void init(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(i==j) dp[i][j]=0; //一个点到它自己的距离为0
else dp[i][j]=inf; //否则为正无穷
}
Floyd的核心代码——三重for循环
void floyd(){
for(int k=1;k<=n;k++) //中转点遍历
for(int i=1;i<=n;i++) //起点遍历
for(int j=1;j<=n;j++) //终点遍历
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]); //取最短路
}
Bellman-Ford O ( n m ) O(nm) O(nm)
他唯一的好处就是可以处理负权边
核心就三行
for(int j=1;j<n;j++)
for(int i=1;i<=m;i++)
dis[e[i].v]=min(dis[e[i].v],dis[e[i].u]+e[i].w);
Spfa O ( k m ) O(km) O(km)
k 为 边 进 入 队 列 的 次 数 _{k为边进入队列的次数} k为边进入队列的次数
—— 基于bellman-ford的队列优化 最坏情况复杂度为
O
(
n
m
)
O(nm)
O(nm)
但是据说它已经死了 但可以判负权边
void spfa(int s){
queue<int>q;
for(int i=1;i<=n;i++){
dis[i]=inf;
vis[i]=0;
}
dis[s]=0; vis[s]=1; q.push(s); //处理起点
while(!q.empty() ){
int t=q.front() ; //取队首
q.pop() ;vis[t]=0;
for(int i=head[t];i;i=e[i].next ){ //链式前向星遍历
int v=e[i].to ;
if(dis[v]>dis[t]+e[i].w ){ //松弛
dis[v]=dis[t]+e[i].w ;
if(!vis[v]){ //判是否访问
vis[v]=1; //标记 入队
q.push(v);
}
}
}
}
}
Dijkstra 堆优化 O ( m + n l o g n ) O(m+nlogn) O(m+nlogn)
注意dijkstra不能处理含有负权边的图
既然是堆优化，那么，priority_queue怎么能没有排面呢
//这一段必背
struct node{
int now,dis;
bool operator <(const node &x)const{
return x.dis<dis;
}//重载运算符的写法还是要好好背一下的
};
priority_queue<node>q;
dj核心
void dj(int s){
//初始化
for(int i=1;i<=n;i++)
dis[i]=inf, vis[i]=0;
//处理起点
q.push((node){s,0});
dis[s]=0;
//核心
while(!q.empty()){
node tt=q.top(); q.pop(); //取队首 并直接弹出
int t=tt.now;
if(!vis[t]){//先判是否访问过 并标记
vis[t]=1;
for(int i=head[t];i;i=e[i].next ){ //链式前向星遍历
int v=e[i].to;
if(dis[v]>dis[t]+e[i].w){ //松弛操作
dis[v]=dis[t]+e[i].w ;
if(!vis[v]) //非空则入队 注意无需标记 会在取到该元素的时候标记
q.push((node){v,dis[v]});
}
}
}
}
}
正文结束
深入探究
判负环
bellman-ford
Bellman-Ford 算法通过不断迭代计算最短路，每轮迭代至少有一个结点得到了最短路。如果经过n-1轮松弛后，仍然存在可以更新的点，则存在负环。
bool flag=0;
for(int i=1;i<=m;i++)
if(dis[e[i].v]>dis[e[i].u]+e[i].w)
flag=1;
if(flag) printf("YES");
else printf("NO");
spfa
如果一个点被访问了 n − 1 n-1 n−1次，那么说明存在负环。
void spfa(int s){
q.push(s);
vis[s]=1;
dis[s]=0;
while(!q.empty()){
int t=q.front(); vis[t]=0; q.pop();
for(int i=head[t];i;i=e[i].next ){
int v=e[i].to;
if(dis[v]>dis[t]+e[i].w ){
dis[v]=dis[t]+e[i].w ;
if(!vis[v]){
cnt[v]++;
if(cnt[v]>=n){
printf("YES\n");
return;
}
vis[v]=1;
q.push(v);
}
}
}
}
printf("NO\n");
}
输出路径
floyd
注意floyd输出最短路径的初始化问题：
- 两种初始化都需要给path[][]赋初值，即
p[i][j]=j。 - 若要求输出字典序最小的路径，则初始化时不需要
if(i==j) dp[i][j]=0，即所有点都初始化为正无穷； - 若不要求字典序最小，则两种初始化方式都可以。
#include<iostream>
#include<cstdio>
#define maxn 5010
#define inf 0x3f3f3f3f
using namespace std;
int n,m,s,t;
int dp[maxn][maxn],p[maxn][maxn];
void init(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++){
dp[i][j]=inf;
p[i][j]=j;
}
}
void floyd(){
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++){
int tmp=dp[i][k]+dp[k][j];
if(dp[i][j]>tmp){
dp[i][j]=tmp;
p[i][j]=p[i][k];
}
if(dp[i][j]==tmp && p[i][j]>p[i][k])
p[i][j]=p[i][k];
}
}
void print(){
printf("%d ",s);
int u=s;
while(u!=t){
printf("%d ",p[u][t]);
u=p[u][t];
}
printf("\n");
}
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
init();
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
dp[u][v]=min(dp[u][v],w);
}
floyd();
print();
}
spfa
用
p
r
e
[
]
pre[]
pre[]数组记录最短路径上该点的上一个节点
p
r
e
[
v
]
=
t
pre[v]=t
pre[v]=t表示 v的前一个节点为t
由于存的是上一个节点，所以只能从ed节点向前倒序输出
因此跑完最短路后，先将路径存入到栈（或vector）中，再倒序输出
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#define maxn 210000
#define maxm 510000
#define inf 0x3f3f3f3f
using namespace std;
int n,m,st,ed,cnt;
int dis[maxn],head[maxn],vis[maxn],pre[maxn];
queue<int>q;
vector<int>path;
struct node{
int to,next,w;
}e[maxm];
void add(int u,int v,int w){
cnt++;
e[cnt].to =v;
e[cnt].next =head[u];
e[cnt].w=w;
head[u]=cnt;
}
void spfa(int s){
for(int i=1;i<=n;i++){
dis[i]=inf;
vis[i]=0;
}
q.push(s);
dis[s]=0;
vis[s]=1;
while(!q.empty()){
int t=q.front() ;
q.pop(); vis[t]=0;
for(int i=head[t];i;i=e[i].next ){
int v=e[i].to ;
if(dis[v]>dis[t]+e[i].w){
dis[v]=dis[t]+e[i].w;
pre[v]=t;
if(vis[v]==0){
vis[v]=1;
q.push(v);
}
}
}
}
if(dis[ed]==inf){
printf("-1");
}
else{
printf("%d\n",dis[ed]);
int tt=ed;
while(tt!=st){
path.push_back(tt);
tt=pre[tt];
}
printf("%d ",st);
while(!path.empty()){
printf("%d ",path.back());
path.pop_back() ;
}
}
}
int main(){
scanf("%d%d%d%d",&n,&m,&st,&ed);
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
}
spfa(st);
// for(int i=1;i<=n;i++){
// printf("%d ",dis[i]);
// }
}
dijkstra
一样的套路
#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#define inf 0x3f3f3f3f
#define maxn 10100
#define maxm 501000
using namespace std;
int n,m,st,ed,cnt;
int dis[maxn],vis[maxn],head[maxn],pre[maxn];
struct edge{
int to,next,w;
}e[maxm];
struct node{
int now,dis;
bool operator <(const node &x)const{
return x.dis<dis;
}
};
priority_queue<node>q;
vector<int>path;
void add(int u,int v,int w){
cnt++;
e[cnt].to =v;
e[cnt].w =w;
e[cnt].next =head[u];
head[u]=cnt;
}
void dj(int s){
for(int i=1;i<=n;i++){
dis[i]=inf; vis[i]=0;
}
q.push((node){s,0});
dis[s]=0;
while(!q.empty()){
node tt=q.top(); q.pop();
int t=tt.now;
if(!vis[t]){
vis[t]=1;
for(int i=head[t];i;i=e[i].next ){
int v=e[i].to;
if(dis[v]>dis[t]+e[i].w){
dis[v]=dis[t]+e[i].w ;
pre[v]=t;
if(!vis[v])
q.push((node){v,dis[v]});
}
}
}
}
if(dis[ed]==inf){
printf("-1");
}
else{
printf("%d\n",dis[ed]);
int tt=ed;
while(tt!=st){
path.push_back(tt);
tt=pre[tt];
}
printf("%d ",st);
while(!path.empty() ){
printf("%d ",path.back());
path.pop_back();
}
}
}
int main(){
scanf("%d%d%d%d",&n,&m,&st,&ed);
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
}
dj(st);
// for(int i=1;i<=n;i++){
// printf("%d ",dis[i]);
// }
}
//附 最短路基本代码
Dfs
#include<iostream>
#include<cstdio>
#include<cstring>
#define inf 0x3f3f3f3f
#define INT_MAX 0x7fffffff
#define maxn 101000
#define maxm 501000
using namespace std;
int n,m,s;
int cnt,dis=inf,dist;
int head[maxn],vis[maxn];
struct node{
int to,next,w;
}e[maxm];
//这里采用链式前向星存图
void add(int u,int v,int w){
e[++cnt].to=v; e[cnt].w=w; e[cnt].next=head[u]; head[u]=cnt;
}
//dis最短路径 dist当前路径长度
//搜索 当前点 t 终点ed
void dfs(int t,int ed){
if(dist>dis) return; //剪枝
if(t==ed) {
dis=min(dist,dis); //取最短
return;
}
//前向星遍历
for(int i=head[t];i;i=e[i].next){
int v=e[i].to; //边i的出点
if(vis[v]==0){
vis[v]=1; dist+=e[i].w;
dfs(v,ed); //递归
vis[v]=0; dist-=e[i].w;
}
}
}
int main(){
scanf("%d%d%d",&n,&m,&s);
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
}
vis[s]=1;
for(int i=1;i<=n;i++){
dis=inf; dist=0;
memset(vis,0,sizeof vis);
dfs(s,i); //循环dfs
if(dis!=inf) printf("%d ",dis);
else printf("%d ",INT_MAX);
}
}
Floyd
#include<iostream>
#include<cstdio>
#define inf 0x3f3f3f3f3f
#define maxn 7500
using namespace std;
int n,m,s;
int dp[maxn][maxn];
void init(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(i==j) dp[i][j]=0;
else dp[i][j]=inf;
}
void floyd(){
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
}
int main(){
scanf("%d%d%d",&n,&m,&s);
init();
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
dp[u][v]=min(dp[u][v],w);
}
floyd();
for(int i=1;i<=n;i++)
printf("%d ",dp[s][i]);
}
Bellman-ford
#include<iostream>
#include<cstdio>
#define inf 0x3f3f3f3f
#define maxn 10100
#define maxm 501000
using namespace std;
int n,m,s;
int dis[maxn];
struct node{
int u,v,w;
}e[maxm];
int main(){
scanf("%d%d%d",&n,&m,&s);
//输入
for(int i=1;i<=m;i++)
scanf("%d%d%d",&e[i].u ,&e[i].v, &e[i].w);
//初始化
for(int i=1;i<=n;i++)
dis[i]=inf;
dis[s]=0;
//核心
for(int j=1;j<n;j++)
for(int i=1;i<=m;i++)
dis[e[i].v]=min(dis[e[i].v],dis[e[i].u]+e[i].w);
//输出
for(int i=1;i<=n;i++)
printf("%d ",dis[i]);
}
spfa
#include<iostream>
#include<cstdio>
#include<queue>
#define maxm 500000
#define maxn 100005
#define inf 0x7fffffff
using namespace std;
struct node {
int to,next,w;
}e[maxm];
int n,m,s,head[maxn],dis[maxn],vis[maxn];
int cnt;
void add(int u,int v,int w){
cnt++;
e[cnt].to=v;
e[cnt].w=w;
e[cnt].next =head[u];
head[u]=cnt;
}
void spfa(int s){
queue<int>q;
for(int i=1;i<=n;i++){
dis[i]=inf;
vis[i]=0;
}
dis[s]=0; vis[s]=1; q.push(s); //处理起点
while(!q.empty() ){
int t=q.front() ; //取队首
q.pop() ;vis[t]=0;
for(int i=head[t];i;i=e[i].next ){ //链式前向星遍历
int v=e[i].to ;
if(dis[v]>dis[t]+e[i].w ){ //松弛
dis[v]=dis[t]+e[i].w ;
if(!vis[v]){ //判是否访问
vis[v]=1; //标记 入队
q.push(v);
}
}
}
}
}
int main(){
int u,v,w;
cin>>n>>m>>s;
while(m--){
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
}
spfa(s);
for(int i=1;i<=n;i++)
printf("%d ",dis[i]);
return 0;
}
dijkstra
#include<iostream>
#include<cstdio>
#include<queue>
#define inf 0x3f3f3f3f
#define maxn 10100
#define maxm 501000
using namespace std;
int n,m,s,cnt;
int dis[maxn],vis[maxn],head[maxn];
struct edge{
int to,next,w;
}e[maxm];
struct node{
int now,dis;
bool operator <(const node &x)const{
return x.dis<dis;
}
};
priority_queue<node>q;
void add(int u,int v,int w){
cnt++;
e[cnt].to =v;
e[cnt].w =w;
e[cnt].next =head[u];
head[u]=cnt;
}
void dj(int s){
for(int i=1;i<=n;i++){
dis[i]=inf; vis[i]=0;
}
q.push((node){s,0});
dis[s]=0;
while(!q.empty()){
node tt=q.top(); q.pop();
int t=tt.now;
if(!vis[t]){
vis[t]=1;
for(int i=head[t];i;i=e[i].next ){
int v=e[i].to;
if(dis[v]>dis[t]+e[i].w){
dis[v]=dis[t]+e[i].w ;
if(!vis[v])
q.push((node){v,dis[v]});
}
}
}
}
}
int main(){
scanf("%d%d%d",&n,&m,&s);
for(int i=1;i<=m;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
}
dj(s);
for(int i=1;i<=n;i++){
printf("%d ",dis[i]);
}
}
534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
