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
难度：中等
时/空限制：2s / 64MB
总通过数：1309
总尝试数：3938
来源：《算法竞赛进阶指南》
算法标签

思路

• 题目就是求一个单源最短路问题，但是这里的路径有两种，一个是无向的边，一个是有向的边，并且保证有向边所连的点不可能有环，而且权值可为负数
• 这题spfa会直接卡掉，要想一个更快的方法，首先题目中保证有向边所连的点不可能有环，所以所有由无向边连起来的点都是在一个块内的，那么我们就把每一个块看成一个点，对于每一个点内部做堆优化的dijkstra，对于点与点之间用拓扑排序的方法更新距离，这样就能大大降低复杂度

代码

#include 
#include 
#include 
#include 
#include 

#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];//存放每一个点的连通块编号
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(int i=0;i<block[bid].size();i++){
     
        heap.push({
     dist[block[bid][i]],block[bid][i]});
    }
    while(heap.size()){
     
        auto t=heap.top();
        heap.pop();
        int ver=t.x;int node=t.y;
        if(st[node])continue;
        st[node]=true;
        for(int i=h[node];~i;i=ne[i]){
     
            int j=e[i];
            if(id[j]!=id[node]&&--din[id[j]]==0)q.push(id[j]);//如果连的是该点连通块外的点，就入度减一，如果入度为0就放入拓扑队列中
            if(dist[j]>dist[node]+w[i]){
     
                dist[j]=dist[node]+w[i];
                 if (id[j] == id[node]) heap.push({
     dist[j], j});//如果在同一个连通块就放入堆中继续更新其他点
            }
        }
    }
}


void topsort()
{
     
    memset(dist, 0x3f, sizeof dist);
    dist[S] = 0;

    for (int i = 1; i <= bcnt; i ++ )
        if (!din[i])
            q.push(i);

    while (q.size())
    {
     
        int t = q.front();
        q.pop();
        dijkstra(t);//对于每一个连通块做dijkstra
    }
}

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;
}