AcWing 342. 道路与航线

题目描述：
农夫约翰正在一个新的销售区域对他的牛奶销售方案进行调查。

他想把牛奶送到 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

思路：
首先用dfs标记出每一个连通块即为block。
连通块内部每一个点都会有一个id作为它属于哪一个连通块的标记，同时每一个连通块也会记录内部有哪些点。
通过id的比较就可以知道两个点是否属于同一个连通块。

本题分为两个阶段。
第一个阶段是输入道路之后，会进行dfs。
第二个阶段为输入航道之后，会进行拓扑排序。在拓扑排序中，会将每个入度为0的点放入q队列中。
每次取出一个连通块进行dijkstra。在dijkstra中，将连通块中所有的点入队，更新所有邻接点的dist。若为同一dist则入队que，否则仅更新。更新不同连通块的dist之后，要对终点的点所在的连通块的入度-1 。

#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
using namespace std;
typedef pair<int,int>PII;
const int N=1e6+10;
int e[N],ne[N],w[N],h[N],idx=0;
bool st[N];
int id[N],din[N],dist[N];
int bcnt=0;
vector<int>block[N];
int T,R,P,S;
void add(int a,int b,int c)
{
    w[idx]=c;
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
void dfs(int u,int bid)
{
    id[u]=bid;
    block[bid].push_back(u);
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!id[j])
        {
            dfs(j,bid);
        }
    }
}
queue<int>q;
void dijkstra(int bid)
{
    priority_queue<PII,vector<PII>,greater<PII>>que;
    for(int i=0;i<block[bid].size();i++)
    {
        que.push({dist[block[bid][i]],block[bid][i]});
    }
    while(!que.empty())
    {
        PII t=que.top();
        que.pop();
        int pos=t.second;
        int dis=t.first;
        if(st[pos])
        {
            continue;
        }
        st[pos]=true;
        for(int i=h[pos];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(id[j]!=id[pos])
            {
                din[id[j]]--;
                if(din[id[j]]==0)
                {
                    q.push(id[j]);
                }
            }
            if(dist[j]>dis+w[i])
            {
                dist[j]=dis+w[i];
                if(id[j]==id[pos])
                {
                    que.push({dist[j],j});
                }
            }
        }
    }
}
void topsort()
{
    for (int i = 1; i <= bcnt; i++)
	{
		if (din[i] == 0)
		{
			q.push(i);
		}
	}
    dist[S]=0;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        dijkstra(t);
    }
}
int main()
{
    memset(h,-1,sizeof h);
    memset(dist,0x3f,sizeof dist);
    memset(st,false,sizeof st);
    cin>>T>>R>>P>>S;
    for(int i=0;i<R;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    for(int i=1;i<=T;i++)
    {
        if(!id[i])
        {
            ++bcnt;
            dfs(i,bcnt);
        }
    }
    for(int i=0;i<P;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        din[id[b]]++;
        add(a,b,c);
    }
    topsort();
	for (int i = 1; i <= T; i++)
	    if (dist[i] > 0x3f3f3f3f / 2) cout << "NO PATH" << endl;
	    else cout << dist[i] << endl;
}