AcWing 1128. 信使
\(AcWing\) \(1128\). 信使
一、题目描述
战争时期，前线有 \(n\) 个哨所，每个哨所可能会与其他若干个哨所之间有通信联系。
信使负责在哨所之间传递信息，当然，这是要花费一定时间的（以天为单位）。
指挥部设在 第一个 哨所。
当指挥部下达一个命令后，指挥部就派出若干个信使向与指挥部相连的哨所送信。
当一个哨所接到信后，这个哨所内的信使们也以同样的方式向其他哨所送信。信在一个哨所内停留的时间可以忽略不计。
直至所有 \(n\) 个哨所全部接到命令后，送信才算成功。
因为准备充足，每个哨所内都安排了足够的信使（如果一个哨所与其他 \(k\) 个哨所有通信联系的话，这个哨所内至少会配备 \(k\) 个信使）。
现在总指挥请你编一个程序，计算出完成整个送信过程 最短需要多少时间 。
输入格式
第 \(1\) 行有两个整数 \(n\) 和 \(m\)，中间用 \(1\) 个空格隔开，分别表示有 \(n\) 个哨所和 \(m\) 条通信线路。
第 \(2\) 至 \(m+1\) 行：每行三个整数 \(i、j、k\)，中间用 \(1\) 个空格隔开，表示第 \(i\) 个和第 \(j\) 个哨所之间存在 双向 通信线路，且这条线路要花费 \(k\) 天。
输出格式
一个整数，表示完成整个送信过程的最短时间。
如果不是所有的哨所都能收到信，就输出\(-1\)。
二、题目解析
- 单源最短路径，一般采用堆优化版本的\(Dijkstra\)算法
- 最短距离的最大值，也就是 完成整个送信过程的最短时间
三、\(Dijkstra+PII\)
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int N = 110;
const int M = 2 * 210; //无向边，开两倍
int n, m;
int h[N], e[M], w[M], ne[M], idx;
void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int d[N];
bool st[N];
int dijkstra() {
int res = 0, cnt = 0;
//初始化为正无穷
memset(d, 0x3f, sizeof d);
d[1] = 0; // 1号点为出发点，距离为0
//小顶堆
priority_queue<PII, vector<PII>, greater<>> q;
q.push({0, 1});
while (q.size()) {
auto u = q.top();
q.pop();
if (st[u.second]) continue; // Dijkstra第一次出队列为最小值
st[u.second] = true;
//求所有最短距离的最大值
res = max(res, u.first);
//记录到达的节点个数
cnt++;
for (int i = h[u.second]; ~i; i = ne[i]) {
int j = e[i];
if (d[j] > d[u.second] + w[i]) {
d[j] = d[u.second] + w[i];
q.push({d[j], j});
}
}
}
//如果可以成功到达每个节点，返回最短距离的最大值，否则返回-1
return cnt == n ? res : -1;
}
int main() {
//加快读入
cin.tie(0), ios::sync_with_stdio(false);
memset(h, -1, sizeof h);
cin >> n >> m;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
printf("%d\n", dijkstra());
return 0;
}
四、\(Dijkstra\)+结构体
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 2 * 210; //无向边，开两倍
int n, m;
int h[N], e[M], w[M], ne[M], idx;
void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int d[N];
bool st[N];
//定义结构体
struct Node {
int id; //结点ID
int dist; //和起点的距离
bool operator<(const Node &t) const {
return dist > t.dist; //重载小于号，父节点距离 大于 孔洞节点 距离，则大元素向下，小元素向上，小顶堆
}
};
int dijkstra() {
int res = 0, cnt = 0;
//初始化为无法到达
memset(d, 0x3f, sizeof d);
d[1] = 0; // 1号点为出发点，距离为0
//小顶堆
priority_queue<Node> q;
q.push({1, 0});
while (q.size()) {
auto u = q.top();
q.pop();
if (st[u.id]) continue;
st[u.id] = true;
res = max(res, u.dist);
cnt++; //出队列时统计个数
//枚举每个出边
for (int i = h[u.id]; ~i; i = ne[i]) {
int j = e[i];
if (d[j] > d[u.id] + w[i]) {
d[j] = d[u.id] + w[i];
q.push({j, d[j]});
}
}
}
return cnt == n ? res : -1;
}
int main() {
//加快读入
cin.tie(0), ios::sync_with_stdio(false);
memset(h, -1, sizeof h);
cin >> n >> m;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
printf("%d\n", dijkstra());
return 0;
}
五、\(SPFA\)解法
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 2 * 210; //无向边，开两倍
const int INF = 0x3f3f3f3f;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int d[N];
bool st[N];
//定义结构体
struct Node {
int id; //节点ID
int dist; //和起点的距离
bool operator<(const Node &t) const {
return dist > t.dist; //重载小于号，父节点距离 大于 孔洞节点 距离，则大元素向下，小元素向上，小顶堆
}
};
// spfa模板
void spfa() {
queue<int> q; //队列
memset(d, 0x3f, sizeof d); //将所有距离初始化为无穷大
//出发点的距离清零
d[1] = 0;
q.push(1); //出发点入队列
st[1] = true; //出发点标识已使用
while (q.size()) {
int u = q.front();
q.pop();
st[u] = false;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (d[j] > d[u] + w[i]) {
d[j] = d[u] + w[i];
if (!st[j]) {
st[j] = true;
q.push(j);
}
}
}
}
}
// 14 ms
int main() {
//加快读入
cin.tie(0), ios::sync_with_stdio(false);
memset(h, -1, sizeof h);
cin >> n >> m;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add(a, b, c), add(b, a, c);
}
spfa();
int res = 0;
for (int i = 2; i <= n; i++) {
if (d[i] == INF) {
res = -1;
break;
}
res = max(res, d[i]);
}
printf("%d\n", res);
return 0;
}
六、\(Floyd\)解法
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
const int INF = 0x3f3f3f3f;
int n, m;
int d[N][N];
// 45 ms
int main() {
//加快读入
cin.tie(0), ios::sync_with_stdio(false);
cin >> n >> m;
//初始化邻接矩阵
memset(d, 0x3f, sizeof d);
for (int i = 1; i <= n; i++) d[i][i] = 0;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
d[a][b] = d[b][a] = min(d[a][b], c);
}
// 5行代码的Floyd
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
int res = 0;
for (int i = 1; i <= n; i++)
if (d[1][i] == INF) {
res = -1;
break;
} else
res = max(res, d[1][i]);
printf("%d\n", res);
return 0;
}
