P3905 道路重建(dijkstra)

该文讲述了如何使用Dijkstra算法解决一道关于道路重建的问题。在给定的图中,需要删除一些道路并计算新的最短路径。作者首先介绍了两种思路,然后提供了C++代码实现,通过构建0权值边并进行最短路搜索找到答案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目链接:P3905 道路重建 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

样例输入: 

3
2
1 2 1
2 3 2
1
1 2
1 3

样例输出:

1

分析:第一次见这样的题,刚开始看到数据范围中给出点数只有100个,我想到的思路是:从A点跑一边最短路,从B点跑一边最短路,将所有从A点能到达的点都与A点建立一条0边,将所有能从B点到达的点都与B点建立一条0边,然后跑一边最短路即可求得答案,但是后来想想发现了一个更简单的方法,那就是将除了要删除的边之外的边的权值直接全部设置为0即可,待删除的边的权值保持不变,这跟第一个思路是相同的,但是第二个思路实现起来更为简单,所以下面代码就是按照第二种思路来实现的。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int h[N],e[N],ne[N],w[N],idx;
int d[N];
bool vis[N];
bool t[103][103];//t[i][j]=true代表从i到j的道路损坏 
typedef pair<int,int> PII;
struct node{
	int u,v,w;
}p[N];
void add(int x,int y,int z)
{
	e[idx]=y;
	w[idx]=z;
	ne[idx]=h[x];
	h[x]=idx++;
}
void dijkstra(int x)
{
	memset(d,0x3f,sizeof d);
	d[x]=0;
	priority_queue<PII,vector<PII>,greater<PII> >q;
	q.push({d[x],x});
	while(!q.empty())
	{
		int now=q.top().second;
		q.pop();
		if(vis[now]) continue;
        vis[now]=true;
		for(int i=h[now];i!=-1;i=ne[i])
		{
			int j=e[i];
			if(d[j]>d[now]+w[i])
			{
				d[j]=d[now]+w[i];
				q.push({d[j],j});
			}
		}
	}
}
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		h[i]=-1;
	for(int i=1;i<=m;i++)
		scanf("%d%d%d",&p[i].u,&p[i].v,&p[i].w);
	int cnt;
	cin>>cnt; 
	for(int i=1;i<=cnt;i++)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		t[u][v]=t[v][u]=true;
	}
	for(int i=1;i<=m;i++)
		if(t[p[i].u][p[i].v])
		{
			add(p[i].u,p[i].v,p[i].w);
			add(p[i].v,p[i].u,p[i].w);
		}
		else
		{
			add(p[i].u,p[i].v,0);
			add(p[i].v,p[i].u,0);
		}
	int b,e;
	cin>>b>>e;
	dijkstra(b);
	printf("%d\n",d[e]);
	return 0;
}

### 问题解析 P1119 灾后重建 是洛谷(Luogu)上的一个经典图论题目,其核心问题是:在一个带权图中,某些节点在特定时间点才会开放,要求在给定的时间内找出两个节点之间的最短路径,前提是这些节点必须已经开放。 Dijkstra算法非常适合解决单源最短路径问题,尤其是在边权非负的情况下。然而,由于本题涉及动态开放的节点,需要对原始Dijkstra算法进行适当调整,以确保在某一时刻查询时,只考虑那些已经开放的节点。 --- ### 解决方案设计 #### 核心思想 - 每次查询是在某个时间节点之后进行的,因此只有在该时间节点之前开放的节点才能被访问。 - 在处理查询前,将所有开放时间小于等于当前查询时间的节点及其边加入图中,然后运行Dijkstra算法[^1]。 - 可以采用预处理的方式逐步构建图,并根据每个查询的时间顺序动态更新图的状态。 --- ### C++ 实现示例 ```cpp #include <iostream> #include <vector> #include <queue> #include <cstring> #include <algorithm> using namespace std; const int MAXN = 105; const int INF = 0x3f3f3f3f; int n, m, q; int open_time[MAXN]; // 每个节点开放的时间 vector<pair<int, int>> adj[MAXN]; // 邻接表:adj[u] 存储 (v, weight) bool visited[MAXN]; int dist[MAXN]; // Dijkstra算法函数,仅考虑开放时间 <= current_time 的节点 void dijkstra(int start, int current_time) { priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; fill(dist, dist + n, INF); fill(visited, visited + n, false); if (open_time[start] > current_time) return; // 起点未开放 dist[start] = 0; pq.push({0, start}); while (!pq.empty()) { int u = pq.top().second; pq.pop(); if (visited[u]) continue; visited[u] = true; for (auto edge : adj[u]) { int v = edge.first; int w = edge.second; if (open_time[v] > current_time) continue; // 节点v未开放 if (dist[v] > dist[u] + w) { dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } } int main() { cin >> n >> m >> q; for (int i = 0; i < n; ++i) { cin >> open_time[i]; } for (int i = 0; i < m; ++i) { int u, v, w; cin >> u >> v >> w; adj[u].push_back({v, w}); adj[v].push_back({u, w}); // 无向图 } while (q--) { int x, y, t; cin >> x >> y >> t; dijkstra(x, t); if (dist[y] == INF || open_time[y] > t) { cout << -1 << endl; } else { cout << dist[y] << endl; } } return 0; } ``` --- ### 关键实现说明 1. **节点开放判断** 每次运行Dijkstra算法前,检查节点是否在当前时间已开放,未开放的节点不参与计算[^2]。 2. **优先队列优化** 使用`priority_queue`实现最小堆,提高查找最近未访问节点的效率。 3. **动态图构建** 图的邻接表在初始化时就加载了全部边,但在每次Dijkstra执行时通过条件过滤掉尚未开放的节点。 4. **输出结果判断** 若目标节点未开放或不可达,则输出 `-1`。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值