洛谷P1073 最优贸易【SPFA】

本文介绍了一种使用SPFA算法解决特定贸易路线问题的方法,通过两次运行SPFA算法,分别计算从起点到终点的最低买入价和最高卖出价,从而找出能够获取最大利润的贸易路线。

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

>Description
C国有 n个大城市和m 条道路,每条道路连接这 n个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路,一部分为双向通行的道路,双向通行的道路在统计条数时也计为 1条。

同一种商品在不同城市的价格不一定相同。但是,同一种商品在同一个城市的买入价和卖出价始终是相同的。

他决定利用商品在不同城市中的差价赚回一点旅费。设 C 国 n 个城市的标号从 1~ n,阿龙决定从 1号城市出发,并最终在 n 号城市结束自己的旅行。在旅游的过程中,任何城市可以重复经过多次,但不要求经过所有 n个城市。阿龙通过这样的贸易方式赚取旅费:他会选择一个经过的城市买入他最喜欢的商品,并在之后经过的另一个城市卖出,用赚取的差价当做旅费。他决定这个贸易只进行最多一次,当然,在赚不到差价的情况下他就无需进行贸易。

假设 C国有 5个大城市,城市的编号和道路连接情况如下图,单向箭头表示这条道路为单向通行,双向箭头表示这条道路为双向通行。
在这里插入图片描述

假设 1~n号城市的水晶球价格分别为 4,3,5,6,1。

阿龙可以选择如下一条线路 1->4->5->4->5,并在第1次到达 5 号城市时以 1的价格买入,在第 2次到达 4号城市时以 6 的价格卖出,赚取的旅费数为 5。

现在给出n个城市的价格,m 条道路的信息(每条道路所连接的两个城市的编号以及该条道路的通行情况)。请你告诉阿龙,他最多能赚取多少旅费。


>Input
第一行包含2个正整数n和m,中间用一个空格隔开,分别表示城市的数目和道路的数目。
第二行 n 个正整数,每两个整数之间用一个空格隔开,按标号顺序分别表示这 n 个城市的商品价格。
接下来 m 行,每行有 3个正整数x,y,z,每两个整数之间用一个空格隔开。如z=1,表示这条道路是城市x到城市y之间的单向道路;如果 z=2,表示这条道路为城市x和城市y之间的双向道路。

>Output
一个整数,表示最多能赚取的旅费。如果没有进行贸易,则输出0。


>Sample Input
5 5
4 3 5 6 1
1 2 1
1 4 1
2 3 2
3 5 1
4 5 2

>Sample Output
5


>解题思路
这一道题想了挺久的 然鹅还是没有想出正解
其实就是分为了两个spfa:
1先只算出从1出发一直到n的进价(最小值)。
2再把道路的走向全部反过来,算出从n出发一直到1的卖价(最大值)。

最后再枚举1~n算出最大的得益。


>代码

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct ooo
{
	int ll,next;
}f[500005],ff[500005];
int n,m,a[100005],h[100005],hh[100005],t,tt,x,y,z,st[300005],c[100005],cc[100005],head,tail,ans;
bool yy[100005];
int main()
{
	memset(c,0x7f,sizeof(c));
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	 scanf("%d",&a[i]);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&z);
		f[++t].ll=y; f[t].next=h[x]; h[x]=t; //顺行的邻接表
		ff[++tt].ll=x; ff[tt].next=hh[y]; hh[y]=tt; //逆行的领接表
		if(z==2) //双向的话要再反过来执行一次
		{
			f[++t].ll=x; f[t].next=h[y]; h[y]=t;
			ff[++tt].ll=y; ff[tt].next=hh[x]; hh[x]=tt;
		}
	}
	
	c[1]=a[1]; head=0; tail=1;
	st[1]=1; yy[1]=1;
	do
	{
		head++;
		for(int i=h[st[head]];i;i=f[i].next)
		 if(c[st[head]]<c[f[i].ll])
		 {
		 	if(c[f[i].ll]==c[0]) 
		 	  c[f[i].ll]=min(a[f[i].ll],c[st[head]]); //如果没有被赋值就要从a和c中选出最小的
		 	else c[f[i].ll]=c[st[head]];
		 	if(!yy[f[i].ll])
		 	{
		 	    st[++tail]=f[i].ll;
		 	    yy[f[i].ll]=1;
		 	}
		 }
		yy[st[head]]=0;
	}while(head<tail);
	
	memset(yy,0,sizeof(yy));
	cc[n]=a[n]; head=0; tail=1;
	st[1]=n; yy[n]=1;
	do
	{
		head++;
		for(int i=hh[st[head]];i;i=ff[i].next)
		 if(cc[st[head]]>cc[ff[i].ll])
		 {
		 	if(cc[ff[i].ll]==0)
		 	  cc[ff[i].ll]=max(cc[st[head]],a[ff[i].ll]); //如果没有被赋值就要从a和c中选出最大的
		 	else cc[ff[i].ll]=cc[st[head]];
		 	if(!yy[ff[i].ll])
		 	{
		 	    st[++tail]=ff[i].ll;
		 	    yy[ff[i].ll]=1;
		 	}
		 }
		yy[st[head]]=0;
	}while(head<tail);
	
	for(int i=1;i<=n;i++) ans=max(ans,cc[i]-c[i]); //算出利润最大数
	printf("%d",ans);
	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、付费专栏及课程。

余额充值