【ACWing】1129. 热浪

题目地址：

https://www.acwing.com/problem/content/1131/

德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪！！！他们的德克萨斯长角牛吃起来不错，可是它们并不是很擅长生产富含奶油的乳制品。农夫John此时身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。这些路线包括起始点和终点一共有$T$个城镇，为了方便标号为$1$到$T$。除了起点和终点外的每个城镇都由 双向道路 连向至少两个其它的城镇。每条道路有一个通过费用（包括油费，过路费等等）。给定一个地图，包含$C$条直接连接$2$个城镇的道路。每条道路由道路的起点$R_s$，终点$R_e$和花费$C_i$组成。求从起始的城镇$T_s$到终点的城镇$T_e$最小的总费用。

输入格式：
第一行：$4$个由空格隔开的整数：$T,C,T_s,T_e$；第$2$到第$C+1$行：第$i+1$行描述第$i$条道路，包含$3$个由空格隔开的整数：$R_s,R_e,C_i$。

输出格式：
一个单独的整数表示从$T_s$到$T_e$的最小总费用。数据保证至少存在一条道路。

数据范围：
$1\le T\le 2500$
$1\le C\le 6200$
$1\le T_s,T_e,R_s,R_e\le T$
$1\le C_i\le 1000$

图是稀疏图，可以用堆优化版Dijkstra算法来做。参考https://blog.csdn.net/qq_46105170/article/details/113816744。代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

typedef pair<int, int> PII;

const int N = 2510;
int n, m;
int st, ed, dis[N];
bool vis[N];
// 邻接矩阵存图，可以防止被平行边卡
int g[N][N];

int dijkstra() {
    priority_queue<PII, vector<PII>, greater<PII> > heap;
    heap.push({0, st});

    memset(dis, 0x3f, sizeof dis);    
    dis[st] = 0;

    while (heap.size()) {
        auto t = heap.top();
        heap.pop();

        int v = t.second, d = t.first;
        // 如果终点出堆了，那么最短路就找到了，直接返回之
        if (v == ed) return dis[v];
		
		// 出堆的元素的最短路已经找到了，标记之
        vis[v] = true;

        for (int i = 1; i <= n; i++) {
            if (!vis[i] && dis[i] > dis[v] + g[v][i]) {
                dis[i] = dis[v] + g[v][i];
                heap.push({dis[i], i});
            }
        }
    }

    return -1;
}

int main() {
    cin >> n >> m;
    cin >> st >> ed;

    memset(g, 0x3f, sizeof g);

    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        // 平行边只存最短的那条
        g[a][b] = g[b][a] = min(g[a][b], c);
    }

    cout << dijkstra() << endl;

    return 0;
}

时间复杂度$O(C\log T)$，空间$O(T^2+C)$。

也可以用SPFA来做。参考https://blog.csdn.net/qq_46105170/article/details/113821633。代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

const int N = 2510;
int n, m;
int s, e, dis[N];
bool st[N];
int g[N][N];

void spfa() {
    memset(dis, 0x3f, sizeof dis);
    dis[s] = 0;
    
    queue<int> q;
    q.push(s);

    while (q.size()) {
        int t = q.front();
        q.pop();
        st[t] = false;

        for (int i = 1; i <= n; i++) {
            if (dis[i] > dis[t] + g[t][i]) {
                dis[i] = dis[t] + g[t][i];
                if (!st[i]) {
                    q.push(i);
                    st[i] = true;
                }
            }
        }
    }
}

int main() {
    cin >> n >> m;
    cin >> s >> e;

    memset(g, 0x3f, sizeof g);

    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = g[b][a] = min(g[a][b], c);
    }

    spfa();

    cout << dis[e] << endl;

    return 0;
}

时间复杂度$O(CT)$（但实际要比这个快很多），空间$O(T^2)$。