【洛谷P4568】飞行路线【分层图最短路】

本文解析了一道关于分层图最短路径的算法题,通过将图分为k+1层,每层表示使用不同数量的免费边,利用Dijkstra算法找到从起点到超级汇点的最短路径,有效地解决了题目中的问题。

题目大意:

题目链接:https://www.luogu.org/problemnew/show/P4568
一张无向图,每条边有权值,可以选择不超过 k k k条路使这条路的权值变为0。求从 S S S T T T的最短路。


思路:

做这道题的原因:随机跳题 P a r t 3 Part3 Part3跳到了分层图最短路的题目 q w q qwq qwq
这道题算是分成图最短路的模板吧。
由于题目中说有 k k k条道路可以免费,所以直接跑最短路暴力判断显然是不行的。
分层图最短路就可以有效解决这种带有 「阶段性」的最短路。
我们把整个图分成 k + 1 k+1 k+1层( 0 ∼ k 0\sim k 0k),第 k k k层表示已经将 k k k条道路免费的图,也就是说,每一层的道路和普通的最短路没有什么区别,只是多了一些从第 i i i层到第 i + 1 i+1 i+1层的道路。这些道路的权值为0,这样就有效解决了免费的情况,因为如果最短路跑到了第 i i i层说明使 i i i条道路免费了。
最终把每一层的终点连向一个超级汇点,权值为0,最短路就是第0层源点到超级汇点的最短路。
这道题还把我 s p f a spfa spfa卡了,敲了个 d i j dij dij才过。


代码:

#include <queue>
#include <cstdio>
#include <cstring>
#define mp make_pair
using namespace std;

const int N=300010,M=3000100;
int n,m,k,S,T,T_,tot,head[N],dis[N];
bool vis[N];

struct edge
{
	int next,to,dis;
}e[M];

void add(int from,int to,int dis)
{
	e[++tot].to=to;
	e[tot].dis=dis;
	e[tot].next=head[from];
	head[from]=tot;
}

void dij()
{
	memset(dis,0x3f3f3f3f,sizeof(dis));
	priority_queue<pair<int,int> > q;
	q.push(mp(0,S));
	dis[S]=0;
    while (q.size())
    {
        int u=q.top().second,v;
        q.pop();
        if (vis[u]) continue;
        vis[u]=1;
        for (int i=head[u];~i;i=e[i].next)
        {
            v=e[i].to;
            if (dis[v]>dis[u]+e[i].dis)
            {
                dis[v]=dis[u]+e[i].dis;
                q.push(mp(-dis[v],v));
            }
        }
    }
}

int main()
{
	memset(head,-1,sizeof(head));
	scanf("%d%d%d%d%d",&n,&m,&k,&S,&T_);
	T=N-1; S++; T_++; k++;
	for (int i=1,x,y,z;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		x++; y++;
		for (int i=1;i<=k;i++)
		{
			add(i*n-n+x,i*n-n+y,z);
			add(i*n-n+y,i*n-n+x,z);
			if (i<k)
			{
				add(i*n-n+x,i*n+y,0);
				add(i*n-n+y,i*n+x,0);
			}
		}
	}
	for (int i=1;i<=k;i++)
		add(i*n-n+T_,T,0);
	dij();
	printf("%d\n",dis[T]);
	return 0;
}
### 关于洛谷 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、付费专栏及课程。

余额充值