洛谷P1576 最小花费 Dijkstra+堆优化

本文探讨了一种解决转账费率最短路径问题的算法。在给定的转账网络中,通过寻找最大比率路径来确定A向B转账所需最小金额,确保B收到100元。采用Dijkstra算法结合堆优化,实现高效路径搜索。

题目描述

在n个人中,某些人的银行账号之间可以互相转账。这些人之间转账的手续费各不相同。给定这些人之间转账时需要从转账金额里扣除百分之几的手续费,请问A最少需要多少钱使得转账后B收到100元。

输入输出格式

输入格式:

 

第一行输入两个正整数n,m,分别表示总人数和可以互相转账的人的对数。

以下m行每行输入三个正整数x,y,z,表示标号为x的人和标号为y的人之间互相转账需要扣除z%的手续费 (z<100)。

最后一行输入两个正整数A,B。数据保证A与B之间可以直接或间接地转账。

 

输出格式:

 

输出A使得B到账100元最少需要的总费用。精确到小数点后8位。

 

输入输出样例

输入样例#1: 复制

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

输出样例#1: 复制

103.07153164

说明

1<=n<=2000,m<=100000

问题分析:

很明显,这是一道最短路的问题,那么,怎么寻找那条通往最小花费的路径呢?

1、由于100元是收到的钱,所以我们需要往前推,那么前一个人的花费就是:100/(1-z%);

2、以此类推,转账的人的花费为100/转账比率,要使花费最小,则必须让比率最大,那就是求最大比率路径的问题了;

代码实现:

#include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
typedef pair<double, int> P;
const int N = 2005;
vector<P>r[N];
vector<P>::iterator it;
double dis[N];
int vis[N];
priority_queue< P, vector<P>, less<P> >q;//优先队列实现堆优化 
int main()
{
	int n, m, x, y, z, s, e;
	memset(dis, 0, sizeof(dis));//初始化为0 
	cin >> n >> m;
	while(m--)
	{
		cin >> x >> y >> z;
		//双向存边 
		r[x].push_back(P(1-0.01*z, y));
		r[y].push_back(P(1-0.01*z, x));
	}
	cin >> s >> e;
	//起点比率为1 
	dis[s] = 1;
	q.push(P(dis[s], s));//起点放入堆 
	//Dijkstra+堆优化 
	while(!q.empty())
	{
		P tmp = q.top();
		q.pop();
		int v = tmp.second; 
		if(vis[v]) 
			continue;
		vis[v] = 1;
		for(it = r[v].begin(); it != r[v].end(); it++)
		{
			double w = (*it).first;//边权值 
			int to = (*it).second;//to someone 
			if(!vis[to] && dis[to] < dis[v] * w)
			{
				dis[to] = dis[v] * w;//比率更大则更新
				q.push(P(dis[to], to));//放入堆 
			}
		}
	}
	printf("%.8f", 100/dis[e]);
}

 

### 使用优化Dijkstra算法在C++中的实现 Dijkstra算法的核心在于逐步扩展当前已知的最短路径,而为了提高效率,可以利用优先队列(最小)来加速选取下一个待处理的节点的过程。以下是基于优化Dijkstra算法在C++中的具体实现。 #### 1. 算法概述 传统的Dijkstra算法通过线性扫描的方式寻找距离起点最近的未访问节点,时间复杂度为 \(O(V^2)\),其中 \(V\) 是图中顶点的数量。当使用二叉作为优先队列时,可以在 \(O(\log V)\) 的时间内完成插入和删除操作,从而将总的时间复杂度降低至 \(O((E+V)\log V)\)[^2],其中 \(E\) 表示图中边的数量。 #### 2. C++ 实现代码 下面是一个完整的优化Dijkstra 算法的 C++ 实现: ```cpp #include <iostream> #include <vector> #include <queue> #include <climits> using namespace std; struct Edge { int to; long long weight; }; // 定义一个小根比较函数 struct Compare { bool operator()(const pair<long long, int>& a, const pair<long long, int>& b) { return a.first > b.first; // 按照距离从小到大排列 } }; void dijkstra(int start, vector<vector<Edge>>& adjList, vector<long long>& dist) { priority_queue<pair<long long, int>, vector<pair<long long, int>>, Compare> pq; // 初始化距离数组 for (int i = 0; i < dist.size(); ++i) { dist[i] = LLONG_MAX; } dist[start] = 0; pq.push({0, start}); while (!pq.empty()) { auto current = pq.top(); pq.pop(); int u = current.second; long long d = current.first; // 如果已经找到了更优的距离,则跳过此节点 if (d > dist[u]) continue; // 遍历相邻节点并尝试更新距离 for (auto& edge : adjList[u]) { int v = edge.to; long long w = edge.weight; if (dist[v] > dist[u] + w) { // 松弛操作 dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } } int main() { int n, m, s; cin >> n >> m >> s; // 输入节点数、边数以及起点编号 vector<vector<Edge>> adjList(n + 1); // 邻接表表示图 for (int i = 0; i < m; ++i) { int from, to, weight; cin >> from >> to >> weight; adjList[from].push_back(Edge{to, weight}); // 单向边 } vector<long long> dist(n + 1); dijkstra(s, adjList, dist); // 输出结果 for (int i = 1; i <= n; ++i) { cout << "Distance from source to node " << i << ": "; if (dist[i] == LLONG_MAX) { cout << "INF\n"; // 若不可达则输出 INF } else { cout << dist[i] << "\n"; } } return 0; } ``` #### 3. 关键点解析 - **数据结构的选择** 使用 `priority_queue` 和自定义比较器实现了最小的功能,能够快速获取当前距离起点最近的节点[^4]。 - **松弛操作** 当发现一条新的路径使得目标节点的距离变得更小时,立即更新其距离值,并将其加入优先队列以便后续进一步探索[^3]。 - **性能提升** 利用优化后的版本显著减少了不必要的重复计算,在稀疏图上的表现尤为突出。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值