AcWing 342. 道路与航线 （双端队列广搜问题，SPFA）

题目描述
农夫约翰正在一个新的销售区域对他的牛奶销售方案进行调查。

他想把牛奶送到T个城镇，编号为1~T。

这些城镇之间通过R条道路 (编号为1到R) 和P条航线 (编号为1到P) 连接。

每条道路i或者航线i连接城镇AiAi到BiBi，花费为CiCi。

对于道路，0≤Ci≤10,0000≤Ci≤10,000;然而航线的花费很神奇，花费CiCi可能是负数(−10,000≤Ci≤10,000−10,000≤Ci≤10,000)。

道路是双向的，可以从AiAi到BiBi，也可以从BiBi到AiAi，花费都是CiCi。

然而航线与之不同，只可以从AiAi到BiBi。

事实上，由于最近恐怖主义太嚣张，为了社会和谐，出台了一些政策保证：如果有一条航线可以从AiAi到BiBi，那么保证不可能通过一些道路和航线从BiBi回到AiAi。

由于约翰的奶牛世界公认十分给力，他需要运送奶牛到每一个城镇。

他想找到从发送中心城镇S把奶牛送到每个城镇的最便宜的方案。

输入格式
第一行包含四个整数T,R,P,S。

接下来R行，每行包含三个整数（表示一个道路）Ai,Bi,CiAi,Bi,Ci。

接下来P行，每行包含三个整数（表示一条航线）Ai,Bi,CiAi,Bi,Ci。

输出格式
第1..T行：第i行输出从S到达城镇i的最小花费，如果不存在，则输出“NO PATH”。

数据范围
1≤T≤250001≤T≤25000,
1≤R,P≤500001≤R,P≤50000,
1≤Ai,Bi,S≤T1≤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

看数据大小，弗洛伊德肯定是跑不了的，根据数据限制，估计一下复杂度在O（nlogn）级别，所以很明显，这是一道单源最短路问题，考虑用dijskra或SPFA来解决，而dijskra无法解决边权值为负数的问题，所以我们只能往SPFA方向考虑。SPFA的复杂度最好是O（m），最坏O（mn），复杂度算不清楚，对这道题来说O（mn）肯定是超了，事实上出题人也卡掉了朴素SPFA的做法，那么我们考虑怎么去优化他。

SPFA的优化算法主要分为3部分。

1.双端队列优化广搜，

2.双向广搜

3.A-star

这里我们考虑用第一种方法。

具体思路是：

        道路和航线合一起建图，然后跑SPFA，当搜到某个值（dist的值）小于队头值时，把该值放到队头，让他优先搜索。以求优化

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
const long long maxx = 0x3f3f3f3f3f3f3f3f;
const long long minn = 0xc0c0c0c0c0c0c0c0;
const double pi = 4.0 * atan(1.0);
#define int long long
#define f(i, n, m) for (long long i = n; i <= m; ++i)
#define unf(i, n, m) for (long long i = n; i >= m; --i)
#define kong NULL
#define debug cout << "sss" << endl;
// #define map unordered_map
#define map gp_hash_table

int t, r, p, s;
const int N = 2e5;
struct ww
{
    int next, to, val;
} pre[N];
int head[N];
int cnt = 1;
void add(int x, int y, int z)
{
    pre[cnt].to = y;
    pre[cnt].val = z;
    pre[cnt].next = head[x];
    head[x] = cnt++;
}
deque<pair<int, int>> que;
int dist[25010];
void bfs()
{
    que.push_front({0, s});
    dist[s] = 0;
    while (!que.empty())
    {
        auto p = que.front();
        que.pop_front();
        for (int i = head[p.second]; i; i = pre[i].next)
        {
            int to = pre[i].to;
            int val = pre[i].val;
            if (dist[to] > dist[p.second] + val)
            {
                dist[to] = dist[p.second] + val;
                if (dist[to] < que.front().first)
                    que.push_front({dist[to], to});
                else
                    que.push_back({dist[to], to});
            }
        }
    }
}
void solve()
{
    cin >> t >> r >> p >> s;
    memset(dist, 0x3f, sizeof(dist));
    f(i, 1, r)
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
        add(y, x, z);
    }
    f(i, 1, p)
    {
        int x, y, z;
        cin >> x >> y >> z;
        add(x, y, z);
    }
    bfs();
    f(i, 1, t)
    {
        if (dist[i] > 10000000)
            cout << "NO PATH" << endl;
        else
            cout << dist[i] << endl;
    }
}

signed main()
{
    ios::sync_with_stdio(false);
    solve();
    return 0;
}