道路与航线（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

在已知spfa超时的情况下我们要怎么做？

分析题意可知，所有双向道路连接的点必然不可能有航线连接，航线也必然不可能形成环

 那么我们把在一个连通块中的点看做是一个集合，航线把这些集合串起来会形成一个拓扑图，也就是有向无环图

在这种“无法走回头路”的路线中我们只要从头开始遍历就确保可以把所有路线都给遍历到，把所有点也给更新到

具体流程就是先读入双向边，然后把相连的点通过dfs装到同一个集合中，并且记录哪些点属于哪些集合，哪些集合里有哪些点

然后读入单向边，也就是航线，在记录两点的同时也要记录哪个点的入度增加了

之后写拓扑排序函数，集合标号从小到大遍历，若入度为0就要入队

之后就是单独处理队头了，每次都要用dijkstra处理一个队头，传给dijkstra的参数是集合标号

dijkstra函数每次都把同一个集合的所有元素push进小根堆中，然后就是做堆优化的dijkstra，但是要注意的是若是搜到了航线就要把目标点的入度减1，同时若是入度减为0就要插入拓扑排序的队列中

之后判断，只有是同一个集合中的点并且被更新过距离才能重新push进小根堆中

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 25010, M = 150010, INF = 0x3f3f3f3f;
int n, mr, mp, S;
int id[N];                                   //id存的是哪个点属于哪个集合 
int h[N], e[M], w[M], ne[M], idx;
int dist[N], din[N];
vector<int> block[N];
int bcnt;
bool st[N];
queue<int> q;
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, 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; i = ne[i])
    {
        int j = e[i];
        if (!id[j])
            dfs(j, bid);
    }
}
void dijkstra(int bid)                                      //这就是连通块编号 
{
    priority_queue<PII,vector<PII>,greater<PII> > heap;
    for(auto u : block[bid])
    heap.push({dist[u], u});                                //每次取出一个连通块，把其中的点都加入集合中 
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.y, distance = t.x;
        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if (id[j] != id[ver] && -- din[id[j]] == 0) q.push(id[j]);   //只要是有一条航线，那么入度就要减一,但是特别要注意的是只有不同于集合中的元素才能往q中插入 
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];                              //即使是用dijkstra不能求负权图，更新一条边总是可以的吧 
				if (id[j] == id[ver]) heap.push({dist[j], j});
            }
        }
    }
}

void topsort()
{
    memset(dist, 0x3f, sizeof dist);                //把双向路和航线初始化完毕之后就用拓扑排序去做了 
    dist[S] = 0;                                    //把开始点初始化为0 

    for (int i = 1; i <= bcnt; i ++ )
    if(!din[i]) q.push(i);                          //刚开始把入度为0的连通块整体加入队列中 

    while (q.size())                                //然后对每个连通块内的点做dijkstra 
    {
        int t = q.front();                          //刚开始就只有一组入度为0的点，但是后面的dijkstra函数运行的时候又会把入度为0的点集又给push进来 
        q.pop();
        dijkstra(t);
    }
}

int main()
{
    cin >> n >> mr >> mp >> S;
    memset(h, -1, sizeof h);

    while (mr -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);          //先连入双向边(道路) 
	}  

    for (int i = 1; i <= n; i ++)            //然后形成连通块，也就是说如果这个点没有被遍历过的话就直接加进去 
        if (!id[i])
        {
            bcnt ++ ;
            dfs(i, bcnt);
        }
        
    while (mp -- )                           //然后加入航线(单向) 
    {
        int a, b, c;
        cin >> a >> b >> c;
        din[id[b]] ++ ;
        add(a, b, c);
    }
    
    topsort();
    
    for (int i = 1; i <= n; i ++ )
    if (dist[i] > INF / 2) cout << "NO PATH" << endl;
    else cout << dist[i] << endl;
    return 0;
}

要加油啊！！