AcWing 1126. 最小花费

\(AcWing\) \(1126\). 最小花费

题目传送门

一、题目描述

在 \(n\) 个人中，某些人的银行账号之间可以互相转账。

这些人之间转账的手续费各不相同。

给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问 \(A\) 最少需要多少钱使得转账后 \(B\) 收到 \(100\) 元。

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

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

最后一行输入两个正整数 \(A,B\)。

数据保证 \(A\) 与 \(B\) 之间可以直接或间接地转账。

输出格式
输出 \(A\) 使得 \(B\) 到账 \(100\) 元最少需要的总费用。

精确到小数点后 \(8\) 位。

二、题目解析

假设初始金钱为N,那么如果要在最后一个人的手里得到\(100\)元，我们可以得到公式：

\[\large N∗(1−z_1\%)∗(1−z_2\%)∗…∗(1−z_n\%)=100 \]

这貌似是小学里的求有关利润问题的公式？我对着样例瞎推了半天。。
那么就可以得到：

\[\large N=\frac{100}{(1−z_1\%)∗(1−z_2\%)∗…∗(1−z_n\%)} \]

所以我们要想使得\(N\)尽可能小，那么就要让 分母尽可能大 才行，即让

\((1−z_1\%)∗(1−z_2\%)∗…∗(1−z_n\%)\)尽可能的大，那么我们就可以用最短路算法来找到一条路径让分母最大。

需要注意的是：我们要使得分母最大，那么应该让每一项的\(z_i\%\)越小才行，所以这里不能用小根堆了，应该改成大根堆，然后更新的时候用:\(d[j] = (double) d[u] * (1 - w[i] * 0.01)\)，貌似\(spfa\)不用考虑这些。

三、\(Dijkstra\)+堆优化

#include <bits/stdc++.h>
using namespace std;

const int N = 2010;
const int M = 2e5 + 10; //边数

typedef pair<double, int> PDI;

int n;          // n个节点
int m;          // m条边
double d[N];    //从A点出发，到达每个点的最大距离
bool st[N];     //点i是不是已经进入队列

int h[N], e[M], ne[M], idx;
double w[M];
void add(int a, int b, double c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void dijkstra(int S) {
    priority_queue<PDI> q; //大根堆
    d[S] = 1;              //剩余的百分比(想像一下手机电池，目前是100%状态出发)
    q.push({1, S});        //大根堆，按距离最大到小排序

    while (q.size()) {
        auto t = q.top();
        q.pop();
        int u = t.second;
        if (st[u]) continue;
        st[u] = true;

        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            double a = 1 - w[i];   // 100%减去消耗率，得到本路径的剩余率,需要与带过的数据连乘
            if (d[j] < d[u] * a) { //利用u更新j的路径最大值
                d[j] = d[u] * a;
                q.push({d[j], j});
            }
        }
    }
}

int main() {
    //加快读入
    cin.tie(0), ios::sync_with_stdio(false);
    memset(h, -1, sizeof h);
    cin >> n >> m;

    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        double w = c * 0.01; //消耗的百分比,举例:从A->B的消耗百分比为2%
        add(a, b, w), add(b, a, w);
    }

    int A, B;
    cin >> A >> B;

    dijkstra(A);
    // ∵ x *w1*w2*w3* ... = 100
    // ∴ x = 100/(w1 * w2 * w3 * ...)
    // dist[B]装的就是从A点出发，到B点的 w1*w2*w3*...的连乘积
    printf("%.8lf\n", 100 / d[B]);
    return 0;
}

四、\(SPFA\)

#include<bits/stdc++.h>
using namespace std;

const int N = 2010;     //点数,看的出来，点数不多，采用邻接矩阵也OK
const int M = 2e5 + 10; //边数
//如果本题想要卡SPFA,也可以卡的死死的，因为最差的是O(n*m)=4e8

int n;          // n个节点
int m;          // m条边
double dist[N]; //从A点出发，到达每个点的最大距离
bool st[N];     //点i是不是已经进入队列

//链接前向星，注意double类型
int h[N], e[M], ne[M], idx;
double w[M];
void add(int a, int b, double c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
//从start出发
void spfa(int S) {
    queue<int> q;
    dist[S] = 1; // 剩余的百分比(想像一下手机电池，目前是100%状态出发)
    q.push(S);

    st[S] = true; //标识在队列中
    while (q.size()) {
        int u = q.front(); //取出当前要处理的节点
        q.pop();
        st[u] = false; // u节点出队列

        //枚举u节点的每一条出边
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];                //对方节点号j
            double a = 1 - w[i];         // 100%减去消耗率，得到本路径的剩余率,需要与带过的数据连乘
            if (dist[j] < dist[u] * a) { //利用u更新j的路径最大值
                dist[j] = dist[u] * a;
                if (!st[j]) {
                    st[j] = true;
                    q.push(j);
                }
            }
        }
    }
}

int main() {
    //加快读入
    cin.tie(0), ios::sync_with_stdio(false);
    memset(h, -1, sizeof h);
    cin >> n >> m;

    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        double w = c * 0.01; //消耗的百分比,举例:从A->B的消耗百分比为2%
        add(a, b, w), add(b, a, w);
    }

    int A, B;
    cin >> A >> B;
    spfa(A);
    // ∵ x *w1*w2*w3* ... = 100
    // ∴ x = 100/(w1 * w2 * w3 * ...)
    // dist[B]装的就是从A点出发，到B点的 w1*w2*w3*...的连乘积
    printf("%.8lf\n", 100 / dist[B]);
    return 0;
}