道路与航线(toposort+dijkstra)

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

输入格式
第一行包含四个整数 T,R,P,S。
接下来 R 行，每行包含三个整数（表示一个道路）Ai,Bi,Ci。
接下来 P 行，每行包含三个整数（表示一条航线）Ai,Bi,Ci。

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

数据范围
1≤T≤25000,
1≤R,P≤50000,
1≤Ai,Bi,S≤T

输入样例：

6 3 3 4
1 2 5
3 4 5
5 6 10
3 5 -100
4 6 -100
1 3 -10

输出样例：

NO PATH
NO PATH
5
0
-95
-100

分析： 这道题目一看就是一个最短路问题，在看完这道题目的数据范围之后，时间复杂度应该是O(nlogn) ,我们可以初步确定使用用dijkstra或者spfa算法。但是这道题目有一个很关键的点，出现了负权边，那我们是不是只能用spfa了呢，spfa的复杂度最坏是O(nm)，所以出题人如果有意要卡是可以卡掉的。那用dijkstra需要怎么处理这个题目呢？
根据题意可以知道，这个图中的航线是不可能出现环的，所以我们可以将图看成很多个连通块，连通块内全都是双向边，连通块与连通块之间只有航线相连（因为航线是单向的）。这样我们就可以在连通块内使用dijkstra算法，而对每一个连通块我们进行拓扑排序。航线为什么不会在连通块内呢？因为如果航线在连通块内，那么肯定会出现环。
整体的思路如下

代码

#include <bits/stdc++.h>
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
int t,r,p,s;
int e[150005],head[25005],ne[150005],w[150005],cnt;
int id[25005],pcnt;//计算有几个团
int pin[25005],d[25005],vis[25005];
vector<int>block[25005];
queue<int>pq;//用于toposort
struct node{
    int dis,pos;
    bool operator <(const node &a) const{
        return a.dis<dis;
    }
};
void add(int a,int b,int c){
    e[cnt]=b,w[cnt]=c,ne[cnt]=head[a],head[a]=cnt++;
}
void dfs(int x,int cnt){
    if(id[x])return ;
    id[x]=cnt;block[cnt].push_back(x);
    for(int i=head[x];~i;i=ne[i])dfs(e[i],cnt);
}
void dijkstra(int tt){
    priority_queue<node>q;
    for(int i=0;i<block[tt].size();i++)q.push((node){d[block[tt][i]],block[tt][i]});
    while(!q.empty()){
        node now=q.top();q.pop();
        int pos=now.pos,dis=now.dis;
        if(vis[pos])continue;
        vis[pos]=1;
        for(int i=head[pos];~i;i=ne[i]){
            int v=e[i];
            if(id[pos]!=id[v]&&--pin[id[v]]==0)pq.push(id[v]);
            if(d[v]>d[pos]+w[i]){
                d[v]=d[pos]+w[i];
                if(id[pos]==id[v])q.push((node){d[v],v});
            }
        }
    }
}
void toposort(){
    memset(d,INF,sizeof(d));d[s]=0;
    for(int i=1;i<=pcnt;i++){
        if(!pin[i])pq.push(i);
    }
    while(!pq.empty()){
        int now=pq.front();pq.pop();
        dijkstra(now);
    }return ;
}
int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d %d %d %d",&t,&r,&p,&s);
    while(r--){
        int a,b,c;scanf("%d %d %d",&a,&b,&c);
        add(a,b,c);add(b,a,c);
    }
    for(int i=1;i<=t;i++){
        if(!id[i])dfs(i,++pcnt);
    }
    while(p--){
        int a,b,c;scanf("%d %d %d",&a,&b,&c);
        add(a,b,c);pin[id[b]]++;
    }toposort();
    for(int i=1;i<=t;i++){
        if(d[i]>=INF/2)cout<<"NO PATH"<<endl;//因为有负权边，所以大于等于INF/2就是没有路径
        else cout<<d[i]<<endl;
    }return 0;
}