2200: [Usaco2011 Jan]道路和航线 （拓扑排序+dijstra）

Description

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) 把奶牛送到每个城镇的最便宜的方案，或者知道这是不可能的。

Input

* 第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

Output

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

Sample Input

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。

Sample Output

NO PATH

NO PATH

5

0

-95

-100

样例输出解释：

FJ的奶牛从4号城镇开始，可以通过道路到达3号城镇。然后他们会通过航线达到5和6号城镇。

但是不可能到达1和2号城镇。

 

 

思路：

因为有负权边，所以不能使用dijstra，但是这个数据量使用spfa会t，所以我们考录heap+dijstra。

如何解决负权边呢？？注意题目：如果有一条航线可以从A_i到B_i，那么保证不可能通过一些道路和航线从B_i回到A_i。

这就说明，单向边一定不会形成环。

所以一个联通块中，不可能有一个起点和终点都在这个强联通块的单向边，然且对于两个强连通块，只能出项从一个块指向另一个块的单向边，若相互指向，则会形成环

那么对于一个联通块，我们可以只考虑双向边，直接使用dijstra，然后对从这个联通块发出的单向边进行更新，更新其他联通块中的dist，然后把处理过的单向边抹去。

 

因为是从s到其他点的距离，所以如果从一个联通块，没有单向边指向它，并且还不是s所在联通块，那么它里面的点都是无法到达的（显然）

 

 

①所以，我们可以按照拓扑序进行更新，每处理完一个联通块，和其单向边，我们就消除单向边造成的入度，然后进行拓扑排序选择联通块。

这样写法s所在联通块并不一定第一个入队，但是其前入队的联通块最短路无法更新，只能消除单向边，写法清晰。

 

②我们也一开始可以就把s的联通块号传入，这样的话，其他入度为0的联通块指出的单向边，我们直接需要将其抹去，消除无效联通块对其他联通快造成的入度。

因为其他入度为0的联通块，是无效的。（代码注释部分）

 

 

 #include<bits/stdc++.h>
 using namespace std;

 int t,r,p,s;
 typedef pair<int,int> pii;
 const int maxn = 5e4+;
 vector<int>belong[maxn];
 struct Node
 {
     int x,y,val,next;
     Node(int x=,int y=,int val=,int next=):x(x),y(y),val(val),next(next) {}
 } node[][maxn<<];

 int head[][maxn];
 int cnt[];
 int tot;
 void add(int x,int y,int val,int t)
 {
     node[t][++cnt[t]].x = x;
     node[t][cnt[t]].y = y;
     node[t][cnt[t]].val = val;
     node[t][cnt[t]].next = head[t][x];
     head[t][x] = cnt[t];
 }
 int cn[maxn];
 int ind[maxn];
 int dist[maxn];
 bool vis[maxn];
 void dfs(int x)
 {
     cn[x] = tot;
     belong[tot].push_back(x);
     for(int i=head[][x]; i; i=node[][i].next)
     {
         int y = node[][i].y;
         if(cn[y])
             continue;
         dfs(y);
     }
 }
 void solve(int s)
 {
     queue<int>que;
     while(!que.empty())
         que.pop();
     for(int i=; i<=tot; i++)
         if(!ind[i])
             que.push(i);
 //    for(int i=1; i<=tot; i++)
 //    {
 //        if(!ind[i] && i != cn[s])
 //        {
 //            for(int j=0; j<belong[i].size(); j++)
 //            {
 //                for(int k=head[1][belong[i][j]]; k; k=node[1][k].next)
 //                {
 //                    --ind[cn[node[1][k].y]];
 //                }
 //            }
 //            ind[i] = -1;
 //            //printf("%d ------ %d\n",ind[i],i);
 //            i=0;
 //        }
 //    }
 //    que.push(cn[s]);
     memset(dist,0x3f,sizeof(dist));
     dist[s] = ;
     priority_queue<pii,vector<pii>,greater<pii> >p;
     while(!que.empty())
     {
         int k = que.front();
         que.pop();
         while(!p.empty())
             p.pop();
         int len = belong[k].size();
         for(int i=; i<len; i++)
         {
             if(dist[belong[k][i]] < 0x3f3f3f3f)
                 p.push(pii(dist[belong[k][i]],belong[k][i]));
         }
         while(!p.empty())
         {
             pii t = p.top();
             p.pop();
             if(vis[t.second])
                 continue;
             vis[t.second] = ;
             for(int i=head[][t.second]; i; i=node[][i].next)
             {
                 if(dist[t.second] + node[][i].val < dist[node[][i].y])
                 {
                     dist[node[][i].y] = dist[t.second] + node[][i].val;
                     p.push(pii(dist[t.second] + node[][i].val,node[][i].y));
                 }
             }
             for(int i=head[][t.second]; i; i=node[][i].next)
             {
                 dist[node[][i].y] = min(dist[node[][i].y],dist[t.second]+node[][i].val);
             }
         }
         for(int i=; i<len; i++)
         {
             for(int j=head[][belong[k][i]]; j; j=node[][j].next)
             {
                 if(--ind[cn[node[][j].y]] == )
                     que.push(cn[node[][j].y]);
             }
         }
     }
 }

 int main()
 {
     cnt[] = cnt[] = ;
     scanf("%d%d%d%d",&t,&r,&p,&s);
     for(int i=; i<=t; i++)
         belong[i].clear();
     for(int i=; i<=r; i++)
     {
         int u,v,k;
         scanf("%d%d%d",&u,&v,&k);
         add(u,v,k,);
         add(v,u,k,);
     }

     for(int i=; i<=p; i++)
     {
         int u,v,k;
         scanf("%d%d%d",&u,&v,&k);
         add(u,v,k,);
     }
     tot = ;
     for(int i=; i<=t; i++)
     {
         if(!cn[i])
         {
             tot++;
             dfs(i);
         }
     }

     for(int i=; i<=cnt[]; i++)
     {
         ind[cn[node[][i].y]]++;
     }
     solve(s);
     for(int i=; i<=t; i++)
     {
         if(dist[i] == 0x3f3f3f3f)
             printf("NO PATH\n");
         else
             printf("%d\n",dist[i]);
     }
 }