洛谷P4568 [JLOI2011]飞行路线(多层图)

本文介绍了一个飞行路线优化问题,通过构建多层图并利用Dijkstra算法解决。问题涉及在有限的免费航班次数下,找到从起点到终点的最低成本路径。文章详细展示了如何通过增加图层数来模拟免费航班使用,以及如何实现Dijkstra算法以找到最优解。

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

Description

Alice和Bob现在要乘飞机旅行,他们选择了一家相对便宜的航空公司。该航空公司一共在n个城市设有业务,设这些城市分别标记为0到n-1,一共有m种航线,每种航线连接两个城市,并且航线有一定的价格。Alice和Bob现在要从一个城市沿着航线到达另一个城市,途中可以进行转机。航空公司对他们这次旅行也推出优惠,他们可以免费在最多k种航线上搭乘飞机。那么Alice和Bob这次出行最少花费多少?

Input

数据的第一行有三个整数,n,m,k,分别表示城市数,航线数和免费乘坐次数。
第二行有两个整数,s,t,分别表示他们出行的起点城市编号和终点城市编号。(0<=s,t<n)
接下来有m行,每行三个整数,a,b,c,表示存在一种航线,能从城市a到达城市b,或从城市b到达城市a,价格为c。(0<=a,b<n,a与b不相等,0<=c<=1000)
 

Output

只有一行,包含一个整数,为最少花费。

5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100
  • Sample Input

8
  • Sample Output

HINT

对于30%的数据,2<=n<=50,1<=m<=300,k=0;
对于50%的数据,2<=n<=600,1<=m<=6000,0<=k<=1;
对于100%的数据,2<=n<=10000,1<=m<=50000,0<=k<=10.

题目是多层图模板题,数据看起来不太大实则有点变态,而且刻意地卡了SPFA算法的最坏情况,所以这里用Dijkstra而不是SPFA(当然SPFA经过合理优化也能过)。建图就是把上层的from点和下层的to点之间连一条免费路,作为使用了一次白嫖机会,所以能白嫖一次就要多建一层图。注意数据范围要开够,不然有一个点会WA(我就是)。

 

#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=110001,M=2500001;
struct Edge{
	int nex,to,cost;
}edge[M];
int n,m,k,S,E;
int tot=0,headlist[N],d[N];
bool vis[N];
inline void adds(int x,int y,int w){//加边 
	edge[++tot].to=y;
	edge[tot].cost=w;
	edge[tot].nex=headlist[x];
	headlist[x]=tot;
}
inline int read(){
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
inline void Dijkstra(int x){
	memset(d,0x3f3f3f3f,sizeof(d));
	d[x]=0;
	priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > points;//用优先队列维护 
	points.push(make_pair(0,x));
	while(!points.empty())
	{
	 int u=points.top().second;
	 points.pop();
	 if(!vis[u])
	 {
	  vis[u]=true;
	  for(int i=headlist[u];i;i=edge[i].nex)
	  {
	   int v=edge[i].to,w=edge[i].cost;
	   if(d[v]>d[u]+w)
	   {
	    d[v]=d[u]+w;
	    points.push(make_pair(d[v],v));
	   }
	  }
	 }
	}
}
int main(){
	n=read();m=read();k=read();S=read();E=read();
	int x,y,w;
	for(int i=1;i<=m;i++)
	{
	 x=read();y=read();w=read();
	 adds(x,y,w);adds(y,x,w);
	 for(int j=1;j<=k;j++)
	 {
	  adds(x+(j-1)*n,y+j*n,0);
	  adds(y+(j-1)*n,x+j*n,0);//上层点与下层点相连,花费为0,表示可以白嫖 
	  adds(x+j*n,y+j*n,w);//下层对应的点相连 
	  adds(y+j*n,x+j*n,w);
	 }
	}
	for(int i=1;i<=k;i++)
	 adds(E+(i-1)*n,E+i*n,0);//为防止在免费次数花完前就到达上层终点,连一条把各层终点串起来的免费通路 
	Dijkstra(S);
	printf("%d",d[E+k*n]);//输出最下层终点 
	return 0;
}

洛谷原题传送门:P4568 [JLOI2011]飞行路线

### 关于 P1948 的分层最短路径问题 #### 问题背景 P1948 是一道典型的 **分层图最短路径问题**。这类问题通常通过构建多个层次的图来模拟某些特殊条件下的状态转移,例如时间、费用或其他约束条件的变化。 --- #### 分层图的概念 分层图是一种扩展原图的方式,在原有基础上增加额外的状态维度(如层数)。每一层对应一种特定的状态或阶段,不同层之间可以通过某种规则相互连接[^3]。这种建模方式非常适合处理带有多重限制的最短路径问题。 --- #### 解题思路分析 对于该问题的核心在于如何利用已知算法求解分层图中的最短路径: 1. **模型转换** 将原始单层图转化为多层图,每层表示不同的状态变化。假设总共有 \( k \) 层,则每个节点会复制成 \( k \) 份,形成新的节点集合。相邻两层间按照题目给定的规则建立边的关系。 2. **适用算法选择** - 如果不存在负权边,可以采用 **Dijkstra 算法** 来高效求解。 ```python import heapq def dijkstra(graph, start_node): dist = {node: float('inf') for node in graph} dist[start_node] = 0 pq = [(0, start_node)] while pq: current_dist, u = heapq.heappop(pq) if current_dist > dist[u]: continue for v, weight in graph[u]: distance = current_dist + weight if distance < dist[v]: dist[v] = distance heapq.heappush(pq, (distance, v)) return dist ``` - 若存在负权边或者需要多次松弛操作验证更优解,则应选用 **Bellman-Ford 算法** 或其队列优化版本——**SPFA 算法**[^2]。 3. **初始化与边界条件** 设置初始点所在的具体位置以及目标终点的位置关系。特别需要注意的是,由于引入了更多虚拟节点和边,因此要仔细定义起始状态及其权重设置[^1]。 4. **复杂度考量** 构造后的分层图规模可能显著增大,需评估所选算法的时间开销是否会超出允许范围。一般情况下,\( O((V+E)\log V) \) 的 Dijkstra 性能优于线性的 Bellman-Ford (\(O(VE)\)) ,但在稀疏图上 SPFA 可能表现更好。 --- #### 示例实现代码 以下是基于 Python 的简单实现框架,展示如何应用上述方法解决问题: ```python from collections import deque, defaultdict def build_layered_graph(original_graph, layers_count, transition_rule): layered_graph = {} # 初始化各层节点并按规则连通它们 for layer in range(layers_count): for node in original_graph.keys(): key = (layer, node) if key not in layered_graph: layered_graph[key] = [] # 添加同层邻居 for neighbor, cost in original_graph[node]: next_key = (layer, neighbor) layered_graph[key].append((next_key, cost)) # 根据transition rule跨层链接 new_layer, extra_cost = transition_rule(layer, node) if new_layer >= 0 and new_layer < layers_count: cross_key = (new_layer, node) layered_graph[key].append((cross_key, extra_cost)) return layered_graph def spfa(graph, source): distances = defaultdict(lambda : float('inf')) predecessors = {} queue = deque() distances[source] = 0 queue.append(source) while queue: current = queue.popleft() for neighbor, edge_weight in graph.get(current, []): potential_new_distance = distances[current] + edge_weight if potential_new_distance < distances[neighbor]: distances[neighbor] = potential_new_distance predecessors[neighbor] = current if neighbor not in queue: queue.append(neighbor) return dict(distances), predecessors ``` --- #### 注意事项 - 转化过程中务必保持逻辑一致性,确保新增加的边满足实际意义; - 对大规模输入数据预估运行效率,必要时采取剪枝策略减少冗余运算; ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值