2019ICPC(银川) - Delivery Route（强连通分量 + 拓扑排序 + dijkstra）

Delivery Route

题目：有n个派送点，x条双向边，y条单向边，出发点是s，双向边的权值均为正，单向边的权值可以为负数，对于单向边给出了一个限制：如果u->v成立，则v->u一定不成立。问，从s出发，到其他所有点的最短路是多少（包括s）。

思路：对于单向边的限制，我们可以这么理解：双向边相连接的点一定组成一个强连通分量，如果一条单向边存在于某个强连通分量中，可以得出：如果“u -> v”，则一定“v -> u”，可以推出单向边一定只存在于连接两个强连通分量，且还可以推出，强连通分量缩点后，连上单向边，此时的图一定是一个有向无环图，于是给出的限制"对于单向边给出了一个限制：如果u->v成立，则v->u一定不成立。"完全成立，于是图的性质我们分析完了。

①似乎这个图的性质可以直接跑dijkstra，的确可以，但是负权边的存在复杂度太大。

②每个强连通分量都可以dijkstra，且图存在拓扑排序，不如让入度为0的缩点先跑dijkstra，然后一条单向边只影响其他强连通分量的一个点的距离，然后按照拓扑序来确定每个强连通分量跑dijkstra的顺序。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <queue>

 #define ll long long
 #define pb push_back
 #define fi first
 #define se second

 using namespace std;

 const int N =  + ;
 const int M =  + ;
 const ll INF = 1e10;
 struct Edge{
     int to, nxt, w;
 }e[M << ];
 struct node{
     int u, v, w;
 };
 struct tmp{
     int now;
     ll w;
     bool friend operator<(const tmp& a, const tmp& b){
         return a.w > b.w;
     }
 };
 int head[N], scc[N], du[N], vis[N], ok[N];
 ll dis[N];
 vector<node > vp[N];//单向边
 vector<int > belong[N];//属于哪个scc
 vector<int > mp[N];//存边
 priority_queue<tmp > pque;
 int n, x, y, s, tot, col;

 inline void add(int u, int v, int w){
     e[tot].to = v; e[tot].nxt = head[u];
     e[tot].w = w; head[u] = tot++;
 }

 //缩点
 void dfs(int now){
     scc[now] = col;
     belong[col].pb(now);
     for(int o = head[now]; ~o; o = e[o].nxt)
         if(!scc[e[o].to]) dfs(e[o].to);
 }

 //检测这个点是不是有效点
 void check(int now){
     ok[now] = ;
     for(auto to : mp[now])
         if(!ok[to]) check(to);
 }

 void dijkstra(int ss){
     while(!pque.empty()) pque.pop();
     if(ss == s) pque.push({ss, dis[ss]}); //图一定是从出发点s开始的
     else{
         //相当于从一个超级源点出发
         for(auto it : belong[scc[ss]]) pque.push({it, dis[it]});
     }
     while(!pque.empty()){
         int u = pque.top().now;
         pque.pop();
         if(vis[u]) continue;
         vis[u] = ;
         for(int o = head[u]; ~o; o = e[o].nxt){
             if(dis[u] + e[o].w < dis[e[o].to]){
                 dis[e[o].to] = dis[u] + e[o].w;
                 pque.push({e[o].to, dis[e[o].to]});
             }
         }
     }
 }

 void top_sort(){
     queue<int > que;
     que.push(scc[s]);//满足的图 应该是从s的连通图出发的拓扑图
     dijkstra(s);
     while(!que.empty()){
         int inx = que.front();
         que.pop();
         for(auto it : vp[inx]){
             //一条单向边影响一个点的距离
             if(dis[it.u] + it.w < dis[it.v]){
                 dis[it.v] = dis[it.u] + it.w;
             }
             //入度0，跑dijkstra
             if(--du[scc[it.v]] == ){
                 que.push(scc[it.v]);
                 dijkstra(it.v);
             }
         }
     }
 }

 void solve(){
     scanf("%d%d%d%d", &n, &x, &y, &s);
     for(int i = ; i <= n; ++i) head[i] = -; tot = ;
     for(int i = ; i <= n; ++i) dis[i] = INF; dis[s] = ;
     int u, v, w;
     for(int i = ; i <= x; ++i){
         scanf("%d%d%d", &u, &v, &w);
         add(u, v, w); add(v, u, w);
         mp[u].pb(v); mp[v].pb(u);
     }

     vector<node > tmp;
     for(int i = ; i <= y; ++i){
         scanf("%d%d%d", &u, &v, &w);
         tmp.pb({u, v, w});
         mp[u].pb(v);
     }
     //图一定是从出发点s开始的，所以从s出发遍历图，无法到达的点，就是无法到达的点
     //检测这个点是不是有效点
     check(s);
     //缩点
     for(int i = ; i <= n; ++i){
         if(!scc[i] && ok[i]){
             ++col;
             dfs(i);
         }
     }
     //入度统计
     for(auto x : tmp){
         if(ok[x.u] && ok[x.v]){//有效点
             vp[scc[x.u]].pb(x);
             ++du[scc[x.v]];
         }
     }
     top_sort();//拓扑序
     for(int i = ; i <= n; ++i){
         if(dis[i] == INF) printf("NO PATH\n");
         else printf("%lld\n", dis[i]);
     }
 }

 int main(){

     solve();

     return ;
 }

 /*
 7 5 3 4
 1 2 5
 3 4 5
 5 6 10
 5 7 4
 6 7 105
 3 5 -100
 4 6 -100
 7 2 -100
 */