【spfa】codevs 1021 玛丽卡

最新推荐文章于 2023-05-11 11:14:53 发布

原创最新推荐文章于 2023-05-11 11:14:53 发布 · 263 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spfa

图论算法专栏收录该内容

74 篇文章

订阅专栏

本文探讨了SPFA算法在处理堵车路径问题时的优化策略，通过仅枚举最短路径上的边来减少计算复杂度。文章详细介绍了如何使用预处理数组保存路径，并提出了一种判断边是否在最短路径上的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

分析

首先是spfa
但是要考虑如何处理堵车的路
一开始想枚举每条边，每枚举一条跑一遍spfa，这样的结果各位一定都知道的
于是想去优化，考虑到如果是非最短路上有堵车，女主一定会走最短路，对答案没有影响，于是只需要枚举最短路上的每一条边即可

对于路径的保存，可以开一个pre数组，在每次松弛边的时候如果d[i]被更新了，就将pre[i]=j,表示当前到i点的最短路径中，j是i的前驱结点。在做完spfa时，
对于结点i,不断地i=pre[i]直到i=源点，这途中的点即为路径。

当然的，如果仅仅判断某条边是否在最短路上，就可以用这条边的起点到汇点的最短距离减去终点到汇点的最短距离的值的绝对值和这条边的权值来比较，若
$∣ d i s [s t a r t] - d i s [e n d] ∣ = w$
则这条边在最短路上

code

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define clean(arry,num); memset(arry,num,sizeof(arry));
int n,m,cnt=0;
const int maxn=1010;
const int maxm=((maxn*(maxn-1))>>1);
struct node{int s;int e;int w;int nxt;}edge[maxm<<1];
bool cut[maxm<<1];
int f[maxn];
int dis[maxn];
bool con[maxn][maxn];
queue<int>path;
//int predis[maxn];
int head[maxn];
inline int read()
{
	int _ans=0;bool _neg=false;char _r=getchar();
	while(_r>'9'||_r<'0'){if(_r=='-')_neg=true;_r=getchar();}
	while(_r>='0'&&_r<='9'){_ans=_ans*10+_r-'0';_r=getchar();}
	return (_neg)?-_ans:_ans;
}
inline void addl(int _u,int _v,int _w)
{
	edge[cnt].e=_v;
	edge[cnt].w=_w;
	edge[cnt].s=_u;
	edge[cnt].nxt=head[_u];
	head[_u]=cnt++;
}

inline void datasetting()
{
	loop(i,1,m)
	{
		int _a,_b,_v;
		_a=read(),_b=read(),_v=read();
		addl(_a,_b,_v);
		addl(_b,_a,_v);
	}
}
inline void spfa(int start)
{
	clean(dis,0x7f);
	deque<int>q;
	dis[start]=0;
	q.push_back(start);
	while(q.empty()==false)
	{
		int _f=q.front();q.pop_front();
		for(int i=head[_f];i!=-1;i=edge[i].nxt)
		{
			int _v=edge[i].e;
			if(con[_f][_v]||con[_v][_f])continue;
			if(dis[_v]>dis[_f]+edge[i].w)
			{
				dis[_v]=dis[_f]+edge[i].w;
				if(!q.empty()&&dis[q.front()]>dis[_v])q.push_front(_v);
				else q.push_back(_v);
			}
		}
	}
}
inline void prespfa(int start)
{
	clean(dis,0x7f);
	deque<int>q;
	dis[start]=0;
	q.push_back(start);
	while(q.empty()==false)
	{
		int _f=q.front();q.pop_front();
		for(int i=head[_f];i!=-1;i=edge[i].nxt)
		{
			int _v=edge[i].e;
			if(dis[_v]>dis[_f]+edge[i].w)
			{
				f[_v]=_f;
				dis[_v]=dis[_f]+edge[i].w;
				if(!q.empty()&&dis[q.front()]>dis[_v])q.push_front(_v);
				else q.push_back(_v);
			}
		}
	}
}
int main()
{
	
    n=read(),m=read();
    clean(head,-1);
    clean(con,false);
    clean(cut,false);
    clean(f,0);
    datasetting();
    int maxx=-INT_MAX;
    prespfa(1);
	int _p=f[n];
	int _b=n;
	while(_b!=1)
	{
		con[_p][_b]=true;
		spfa(1);
		con[_p][_b]=false;
		_b=_p,_p=f[_b];
		maxx=max(maxx,dis[n]);
	}
	printf("%d",maxx);
	return 0;
}