SPFA和dijkstra优化

SPFA

• 单源最短路，好哇

• 时间复杂度玄

• 无畏负权边，容易被卡负环

• 好打好理解

• $SLF$优化：如果当前要入队一个点$i$，如果$dis[i]<dis[que[head]]$ (比队首要优)就放入队首，否则就放入队尾

• $LLL$优化：如果当前的出队的数（$que[head]$），他的$dis$大于队列中所有$dis$的平均值，那么就把$que[head]$入队尾，然后$continue$

• 可以用$STL$的$deque$来实现$SLF$，$LLL$乱搞就行

inline void spfa()
{
	ll z=0,length=1;
	while (que.size())que.pop_front();
	memset(bz,1,sizeof(bz));
	memset(dis,100,sizeof(dis));
	que.push_front(S),dis[S]=bz[S]=0;
	while (que.size())
	{
		ll now=que.front();
		if (length*dis[now]>z)
		{//LLL优化
			que.pop_front(),que.push_back(now);
			continue;
		}
		--length,z-=dis[now];
		que.pop_front(),bz[now]=1;
		rep(i,now)
		{
			if (dis[now]+len[i]<dis[tov[i]])
			{
				dis[tov[i]]=dis[now]+len[i];
				if (bz[tov[i]])
				{
					bz[tov[i]]=0,z+=dis[tov[i]],++length;
					if (que.empty() || dis[que.front()]<dis[tov[i]])que.push_back(tov[i]);//比队头劣则入队尾
					else que.push_front(tov[i]);//反之则入队头
				}
			}
		}
	}
}

---

dijkstra

• 单源最短路，更好

• 时间复杂度$O((n+m)lo{g}_{2}n)$，很多题目一般可以看成$O(nlo{g}_{2}n)$乘上个$3$左右的常数

• 只要没有负权边就强大通用

• 优化用$STL$的$priority$_$queue$就行了

• 堆优化完比$SPFA$还短，以后都不打SPFA.jpg

struct node
{
	ll x,y;
	bool operator <(const node &a)const
	{
		return a.y<y;
	}
};
priority_queue<node>que;

inline void dijkstra()
{
	while (!que.empty())que.pop();
	memset(dis,100,sizeof(dis));
	memset(bz,0,sizeof(bz));
	que.push((node){S,dis[S]=0});
	while (!que.empty())
	{
		node now=que.top();que.pop();
		if (bz[now.x])continue;bz[now.x]=1;
		rep(i,now.x)
		{
			if (dis[now.x]+len[i]<dis[tov[i]])
			{
				dis[tov[i]]=dis[now.x]+len[i];
				if (!bz[tov[i]])que.push((node){tov[i],dis[tov[i]]});
			}
		}
	}
}