道路重建（C++，Dijkstra）

最新推荐文章于 2023-12-03 11:08:55 发布

WitheredSakura_

最新推荐文章于 2023-12-03 11:08:55 发布

阅读量538

点赞数 1

分类专栏：图文章标签： c++ 图论算法 Dijkstra

本文链接：https://blog.csdn.net/m0_74036684/article/details/128620513

版权

图专栏收录该内容

33 篇文章 0 订阅

订阅专栏

题目描述

从前，在一个王国中，在 $n$ 个城市间有 $m$ 条道路连接，而且任意两个城市之间至多有一条道路直接相连。在经过一次严重的战争之后，有 $d$ 条道路被破坏了。国王想要修复国家的道路系统，现在有两个重要城市 $A$ 和 $B$ 之间的交通中断，国王希望尽快的恢复两个城市之间的连接。你的任务就是修复一些道路使 $A$ 与 $B$ 之间的连接恢复，并要求修复的道路长度最小。

输入格式

输入文件第一行为一个整数 $n$ （ $2 < n \leq 100$ ）,表示城市的个数。这些城市编号从 $1$ 到 $n$ 。

第二行为一个整数 $m$ （ $n-1≤m≤\frac{1}{2} n(n-1)$ ），表示道路的数目。

接下来的 $m$ 行，每行 $3$ 个整数 $i, j, k$ （ $1 \leq i, j \leq n, i \neq = j, 0 < k \leq 100$ ），表示城市 $i$ 与 $j$ 之间有一条长为 $k$ 的道路相连。

接下来一行为一个整数 $d$ （ $1 \leq d \leq m$ ），表示战后被破坏的道路的数目。在接下来的 $d$ 行中，每行两个整数 $i$ 和 $j$ ，表示城市 $i$ 与 $j$ 之间直接相连的道路被破坏。

最后一行为两个整数A和B，代表需要恢复交通的两个重要城市。

输出格式

输出文件仅一个整数，表示恢复 $A$ 与 $B$ 间的交通需要修复的道路总长度的最小值。

样例 #1

样例输入 #1

样例输出 #1

解题思路：

与普通的单源最短路径相比，稍微有点不同

只需要把未损毁的道路边权视作 $0$

只有已损毁的道路边权有效

之后套用Dijkstra算法即可

AC代码如下

#include <iostream>
#include <vector>
#include <queue>
#include <memory.h>
using namespace std;
const int max_n = 100;
const int max_m = max_n * (max_n - 1) / 2;
const int NaN = 0x3F3F3F3F;

class queue_greater {
public:
	bool operator()(pair<int, int>p_1, pair<int, int>p_2) {
		return p_1.first > p_2.first;
	}
};

priority_queue<pair<int, int>, vector<pair<int, int>>, queue_greater>p_q;
struct edge { int v, p, next; bool d; }edges[max_m * 2];//链式前向星
int head[max_n + 1]{ -1 };
int tot = -1;
bool book[max_n + 1] = { false };//最短路径集
int dists[max_n + 1] = { NaN };

void add_edge(int u, int v, int p) {//存图
	edges[++tot] = { v,p,head[u],false }; head[u] = tot;
	edges[++tot] = { u,p,head[v],false }; head[v] = tot;
}

void damage_edge(int u, int v) {//损毁
	int index;
	for (index = head[u]; index != -1; index = edges[index].next) {
		if (edges[index].v == v) {
			edges[index].d = true;
			if (index % 2 == 0) edges[++index].d = true;
			else edges[--index].d = true;
		}
	}
}

int dijkstra(const int start, const int end) {//Dijkstra
	dists[start] = 0;
	p_q.push(pair<int, int>(0, start));//初始化

	while (!p_q.empty()) {
		int node = p_q.top().second;
		int dist = p_q.top().first;
		p_q.pop();//取出队首
		
		if (book[node]) continue;//已加入最短路径集
		if (node == end) {//到达B城市
			return dist;
		}
		book[node] = true;//未加入最短路径集

		for (int index = head[node]; index != -1; index = edges[index].next) {//尝试更新最短路径
			int v = edges[index].v;
			if (edges[index].d) {//损毁
				if (dists[v] > dist + edges[index].p) {
					dists[v] = dist + edges[index].p;
					p_q.push(pair<int, int>(dist + edges[index].p, v));
				}
			}
			else {//未损毁
				if (dists[v] > dist) {
					dists[v] = dist;
					p_q.push(pair<int, int>(dist, v));
				}
			}
		}
	}
}

int main() {
	memset(head + 1, -1, sizeof(int) * max_n);
	memset(dists + 1, 0x3F, sizeof(int) * max_n);
	int n, m, d, u, v, p, start, end;
	cin >> n >> m;
	for (int i = 0; i < m; i++) {
		cin >> u >> v >> p;
		add_edge(u, v, p);
	}
	cin >> d;
	for (int i = 0; i < d; i++) {
		cin >> u >> v;
		damage_edge(u, v);
	}
	cin >> start >> end;
	
	cout << dijkstra(start, end);
	return 0;
}