NC50381 道路和航线

题目链接

题目

题目描述

FarmerJohn正在一个新的销售区域对他的牛奶销售方案进行调查。他想把牛奶送到T个城镇，编号为1到T。这些城镇之间通过R条道路（编号为1到R）和P条航线（编号为1到P）连接。每条道路i或者航线i连接城镇 $A_i$ 到 $B_i$ ，花费为 $C_i$ 。
对于道路，$0 \le C_i \le 10^4$ ，然而航线的花费很神奇，花费 $C_i$ ​可能是负数。道路是双向的，可以从 $A_i$ ​到 $B_i$ ​，也可以从 $B_i$ ​到 $A_i$ ​，花费都是 $C_i$ ​。然而航线与之不同，只可以从 $A_i$​ 到 $B_i$ ​。
事实上，由于最近恐怖主义太嚣张，为了社会和谐，出台了一些政策保证：如果有一条航线可以从 $A_i$ ​到 $B_i$ ​，那么保证不可能通过一些道路和航线从 $B_i$ ​回到 $A_i$ ​。由于FJ的奶牛世界公认十分给力，他需要运送奶牛到每一个城镇。他想找到从发送中心城镇S把奶牛送到每个城镇的最便宜的方案，或者知道这是不可能的。

输入描述

第一行为四个空格隔开的整数：T,R,P,S；
第二到第R+1行：三个空格隔开的整数（表示一条道路）：$A_i,B_i$ 和 $C_i$ ；
第R+2到R+P+1行：三个空格隔开的整数（表示一条航线）：$A_i,B_i$ 和 $C_i$ 。

输出描述

输出T行，第i行表示到达城镇i的最小花费，如果不存在输出NO PATH。

示例1

输入

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

说明

一共六个城镇。在1和2，3和4，5和6之间有道路，花费分别是5,5,10。同时有三条航线：$3 \to5$ ，$4 \to6$ 和 $1 \to3$ ，花费分别是-100,-100,-10。FJ的中心城镇在城镇4。FJ的奶牛从4号城镇开始，可以通过道路到达3号城镇。然后他们会通过航线达到5和6号城镇。但是不可能到达1和2号城镇。

备注

对于全部数据，$1 \le T \le 2.5 \times 10^4,1 \le R,P \le 5 \times 10^4,1 \le A_i,B_i,S \le T$ 。保证对于所有道路，$0 \le C_i \le 10^4$ ，对于所有航线，$-10^4 \le C_i \le 10^4$ 。

题解

方法一

知识点：最短路。

直接跑SPFA可以，但要加个优化 Small Label First(SLF) ：一个需要入队的点的距离小于队首点的距离则这个点放在队首，否则放在队尾。

时间复杂度 $O(k(R+P))$

空间复杂度 $O(T+R+P)$

方法二

知识点：最短路，拓扑排序。

由于只有航路是可能负权的，道路都是正的，因此在连通航路之前先把每个道路连接的连通块记录下来，当作一个区域。连通航路后，由于航路是单向的且两个区域之间应该也是单向的，因此区域之间是个DAG。于是，按照区域之间的拓扑序跑最短路即可。最短路中特判一下，一条边两个点不在一个区域里面就是航道，只更新不入队。

一开始需要把每个入度为 $0$ 的区域都放入拓扑队列中，而不能只放起点所在的区域，因为其他区域也许可能不和起点连通，但他们依旧算在某个连通的区域的入度里面，不放入队列可能导致连通区域入度无法减为 $0$ 。

每次跑一个新的区域时，要把这个区域所有点放入队列，即把每个点都当作起点。

时间复杂度 $O(T + (T+R+P)\log(R))$

空间复杂度 $O(T+R+P)$

代码

方法一

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
template<class T>
struct Graph {
    struct edge {
        int v, nxt;
        T w;
    };
    int idx;
    vector<int> h;
    vector<edge> e;
 
    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }
 
    void add(int u, int v, T w) {
        e[++idx] = edge{ v,h[u],w };
        h[u] = idx;
    }
};
 
const int N = 25000 + 7, M = 50000 * 2 + 50000 + 7;
Graph<int> g(N, M);
int T, R, P, S;
 
bool vis[N];
int dis[N];
deque<int> dq;//Small Label First优化
void SPFA(int st) {
    for (int i = 1;i <= T;i++) dis[i] = 0x3f3f3f3f;
    vis[st] = 1;
    dis[st] = 0;
    dq.push_back(st);
    while (!dq.empty()) {
        int u = dq.front();
        dq.pop_front();
        vis[u] = 0;
        for (int i = g.h[u];i;i = g.e[i].nxt) {
            int v = g.e[i].v, w = g.e[i].w;
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                if (!vis[v]) {
                    if (dq.size() && dis[v] < dis[dq.front()]) dq.push_front(v);
                    else dq.push_back(v);
                    vis[v] = 1;
                }
            }
        }
    }
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> T >> R >> P >> S;
    for (int i = 1;i <= R;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
        g.add(v, u, w);
    }
    for (int i = 1;i <= P;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
    }
    SPFA(S);
    for (int i = 1;i <= T;i++) {
        if (dis[i] > 1e9) cout << "NO PATH" << '\n';
        else cout << dis[i] << '\n';
    }
    return 0;
}

方法二

#include <bits/stdc++.h>
#define ll long long
 
using namespace std;
 
template<class T>
struct Graph {
    struct edge {
        int v, nxt;
        T w;
    };
    int idx;
    vector<int> h;
    vector<edge> e;
 
    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }
 
    void add(int u, int v, T w) {
        e[++idx] = edge{ v,h[u],w };
        h[u] = idx;
    }
};
 
const int N = 25000 + 7, M = 50000 * 2 + 50000 + 7;
Graph<int> g(N, M);
int T, R, P, S;
 
int idx;
int id[N];
vector<int> block[N];
void dfs(int u) {
    id[u] = idx;
    block[idx].push_back(u);
    for (int i = g.h[u];i;i = g.e[i].nxt) {
        int v = g.e[i].v;
        if (id[v]) continue;
        dfs(v);
    }
}
 
 
bool vis[N];
int dis[N];
struct node {
    int v, w;
    friend bool operator<(const node &a, const node &b) {
        return a.w > b.w;
    }
};
priority_queue<node> pq;
int deg[N];
queue<int> q;
void dijkstra(int st) {
    for (auto u : block[st]) pq.push({ u,dis[u] });
    while (!pq.empty()) {
        int u = pq.top().v;
        pq.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = g.h[u];i;i = g.e[i].nxt) {
            int v = g.e[i].v, w = g.e[i].w;
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                if (id[v] == id[u]) pq.push({ v,dis[v] });
            }
            if (id[v] != id[u] && --deg[id[v]] == 0) q.push(id[v]);
        }
    }
}
 
void toposort() {
    for (int u = 1;u <= T;u++) dis[u] = 0x3f3f3f3f;
    dis[S] = 0;
    for (int x = 1;x <= idx;x++) if (!deg[x]) q.push(x);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        dijkstra(u);
    }
}
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> T >> R >> P >> S;
    for (int i = 1;i <= R;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
        g.add(v, u, w);
    }
    for (int u = 1;u <= T;u++) {
        if (id[u]) continue;
        idx++;
        dfs(u);
    }
    for (int i = 1;i <= P;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
        deg[id[v]]++;
    }
    toposort();
    for (int i = 1;i <= T;i++) {
        if (dis[i] > 1e9) cout << "NO PATH" << '\n';
        else cout << dis[i] << '\n';
    }
    return 0;
}