题目描述

Farmer John正在一个新的销售区域对他的牛奶销售方案进行调查。他想把牛奶送到T个城镇 (1 <= T <= 25,000)，编号为1T。这些城镇之间通过R条道路 (1 <= R <= 50,000，编号为1到R) 和P条航线 (1 <= P <= 50,000，编号为1到P) 连接。每条道路i或者航线i连接城镇A_i (1 <= A_i <= T)到B_i (1 <= B_i <= T)，花费为C_i。对于道路，0 <= C_i <= 10,000;然而航线的花费很神奇，花费C_i可能是负数(-10,000 <= C_i <= 10,000)。道路是双向的，可以从A_i到B_i，也可以从B_i到A_i，花费都是C_i。然而航线与之不同，只可以从A_i到B_i。事实上，由于最近*太嚣张，为了社会和谐，出台 了一些政策保证：如果有一条航线可以从A_i到B_i，那么保证不可能通过一些道路和航线从B_i回到A_i。由于FJ的奶牛世界公认十分给力，他需要运送奶牛到每一个城镇。他想找到从发送中心城镇S(1 <= S <= T) 把奶牛送到每个城镇的最便宜的方案，或者知道这是不可能的。

输入格式

第1行：四个空格隔开的整数: T, R, P, and S 第2到R+1行：三个空格隔开的整数（表示一条道路）：A_i, B_i 和 C_i 第R+2到R+P+1行：三个空格隔开的整数（表示一条航线）：A_i, B_i 和 C_i

输出格式

第1到T行：从S到达城镇i的最小花费，如果不存在输出"NO PATH"。

样例

样例输入

6 3 3 4

1 2 5

3 4 5

5 6 10

3 5 -100

4 6 -100

1 3 -10

样例输入解释：一共六个城镇。在1-2，3-4，5-6之间有道路，花费分别是5，5，10。同时有三条航线：3->5， 4->6和1->3，花费分别是-100，-100，-10。FJ的中心城镇在城镇4。

样例输出

NO PATH

NO PATH

5

0

-95

-100

样例输出解释：FJ的奶牛从4号城镇开始，可以通过道路到达3号城镇。然后他们会通过航线达到5和6号城镇。 但是不可能到达1和2号城镇。

分析

正解

我们可以发现题目中有两种边，一种是双向边，边权非负，另一种是单向边，边权可能为正

如果我们用Dij直接去跑最短路，显然是不可以的，因为题目中有负权

如果我们用SPFA 呢，显然会被卡掉

所以我们考虑一下它所具有的的某种性质

双向建的边是非负的，跑Dij是没有问题的，但是问题就是题目中还有单项负权边

我们仔细读一下题就可以发现一个重要的性质：负权的边不会出现环

那么我们就可以把强连通分量缩点，这样缩点之后的图就变成了一个有向无环图

这样就可以在强连通分量内使用Dij，分量外使用拓扑排序更新答案

代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn=150005;
int t,r,p,s,head[maxn],tot=1,cnt;
struct asd{
    int to,next,val;
}b[maxn];
void ad(int aa,int bb,int cc){
    b[tot].to=bb;
    b[tot].val=cc;
    b[tot].next=head[aa];
    head[aa]=tot++;
}
bool vis[maxn];
int shuyu[maxn],dis[maxn];
vector<int> jl[maxn];
void dfs(int now){
    shuyu[now]=cnt,vis[now]=1,jl[cnt].push_back(now);
    for(int i=head[now];i!=-1;i=b[i].next){
        int u=b[i].to;
        if(vis[u])continue;
        dfs(u);
    }
}
struct jie{
    int num,jz;
    jie(int aa=0,int bb=0){
        num=aa,jz=bb;
    }
    bool operator < (const jie& A) const {
        return jz>A.jz;
    }
};
int ru[maxn];
queue<int> q;
priority_queue<jie> Q;
void dij(){
    dis[s]=0;
    while(!q.empty()) {
        int xx=q.front();
        q.pop();
        for(int i=0;i<jl[xx].size();i++){
            Q.push(jie(jl[xx][i],dis[jl[xx][i]]));
        }
        while(!Q.empty()){
            int now = Q.top().num;
            Q.pop();
            if(vis[now]) continue;
            vis[now]=1;
            for(int i=head[now];i!=-1;i=b[i].next){
                int u=b[i].to;
                if(dis[u]>dis[now]+b[i].val){
                    dis[u]=dis[now]+b[i].val;
                    if(shuyu[now]==shuyu[u]) Q.push(jie(u,dis[u]));
                }
                if(shuyu[u]!=shuyu[now] && (--ru[shuyu[u]]==0)) q.push(shuyu[u]); 
            }
        }
    }
}
int main(){
    memset(head,-1,sizeof(head));
    scanf("%d%d%d%d",&t,&r,&p,&s);
    for(int i=1;i<=r;i++){
        int aa,bb,cc;
        scanf("%d%d%d",&aa,&bb,&cc);
        ad(aa,bb,cc);
        ad(bb,aa,cc);
    }
    for(int i=1;i<=t;i++){
        if(!vis[i]) cnt++,dfs(i);
    }
    for(int i=1;i<=p;i++){
        int aa,bb,cc;
        scanf("%d%d%d",&aa,&bb,&cc);
        ad(aa,bb,cc);
        ru[shuyu[bb]]++;
    }
    memset(vis,0,sizeof(vis));
    memset(dis,0x7f,sizeof(dis));
    for(int i=1;i<=cnt;i++) if(ru[i]==0) q.push(i);
    dij();
    for(int i=1;i<=t;i++){
        if(dis[i]>INF) printf("NO PATH\n");
        else printf("%d\n",dis[i]);
    }
    return 0;
}

水过

当然，如果是在考试的时候，正解肯定是很难想到

即使是想到了，又是缩点又是拓扑排序，又是Dij，分起来写还好点，如果合在一起，难免有点代码量

而且，如果最后你调试了半天还没有暴力分高，岂不是很尴尬

所以我们就尝试这用SPFA水一下

其实SPFA本质上还是Bellman Ford的优化版本

那么Bellman Ford是怎么运作的呢

实际上它是使用全部的边对于起点到其他n-1个点的路径进行松弛,重复n-1次

算法复杂度为O(VE)

这样的复杂度几千条边还勉强可以接受，但是十万以上的边是肯定不可以的

于是就有了优化版本SPFA，它的优化之处在哪里呢

实际上我们来想一下，对于普通的Bellman Ford，其实有些边是根本松弛不动的

所以我们优化的方向就是把肯定不能松弛其它节点的节点排除在外

我们不去考虑哪些节点不能松弛其它节点，而是考虑哪些节点可以松弛其它节点

很显然，只有当前已经松弛成功过的节点才有可能松弛其它的节点

因此这时，我们就用一个栈来记录那些已经松弛成功的节点

每次我们只要从栈中取出节点松弛就可以了

那么时间复杂度呢？

SPFA算法的时间复杂度是不可靠的，一般情况下为O(E)，而在极限情况下也有可能达到Bellman-ford算法的复杂度，即O(V*E)

其实，想要把SPFA卡掉还是很容易的，我们可以随便建一个网格图

因为网格图中的边比较稠密，所以SPFA稍有不慎变会误入歧途，然后多走很多条边

但是，网上也有很多关于SPFA的优化，其实就是想让普通的栈更接近优先队列

因为如果你的栈里有很多个已经松弛过的节点，你肯定希望拿出一个值比较小的节点去松弛其他的节点

因为这样一次松弛成功的几率比较大

所以，我们尽量使维护的栈更接近一个优先队列，也就是权值小的先出栈

目前比较常见的有两种方法，一种是把要插入的元素的值和栈顶元素比较，如果比栈顶元素小，那么就把这个元素放在占栈顶，否则放在栈底

另一种方法就是把与队首元素比较改成了与队中元素的平均值比较，思路差不多

对于这道题，我们可以用第一种方法水过

#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=150005;
struct asd{
	ll from,to,next,val;
}b[maxn];
ll head[maxn],tot=1;
void ad(ll aa,ll bb,ll cc){
	b[tot].from=aa;
	b[tot].to=bb;
	b[tot].next=head[aa];
	b[tot].val=cc;
	head[aa]=tot++;
}
deque<ll> q;
bool vis[maxn];
ll dis[maxn];
void SPFA(ll xx){
	memset(dis,0x3f,sizeof(dis));
	dis[xx]=0,vis[xx]=1;
	q.push_back(xx);
	while(!q.empty()){
		ll now=q.front();
		q.pop_front();
		vis[now]=0;
		for(ll i=head[now];i!=-1;i=b[i].next){
			ll u=b[i].to;
			if(dis[u]>dis[now]+b[i].val){
				dis[u]=dis[now]+b[i].val;
				if(!vis[u]){
					if(!q.empty()&&dis[u]>=dis[q.front()]) q.push_back(u);
                    else q.push_front(u);
					vis[u]=1;
				}
			}
		}
	}
}
int main(){
	memset(head,-1,sizeof(head));
	ll t,r,p,s;
	scanf("%lld%lld%lld%lld",&t,&r,&p,&s);
	for(ll i=1;i<=r;i++){
		ll aa,bb,cc;
		scanf("%lld%lld%lld",&aa,&bb,&cc);
		ad(aa,bb,cc),ad(bb,aa,cc);
	}
	for(ll i=1;i<=p;i++){
		ll aa,bb,cc;
		scanf("%lld%lld%lld",&aa,&bb,&cc);
		ad(aa,bb,cc);
	}
	SPFA(s);
	for(ll i=1;i<=t;i++){
		if(dis[i]==0x3f3f3f3f3f3f3f3f) printf("NO PATH\n");
		else printf("%lld\n",dis[i]);
	}
	return 0;
}

其实大家还可以想一下，如果我们把用优先队列，改成用小根堆去维护，会变成什么样子

或者是裸的Bellman Ford加点特判，又会是什么样子

最后提醒大家一下，正权最短路尽量用DIJ

负权最短路和最长路千万不要用DIJ，卡成0分都有可能