信息学奥赛一本通 1344：【例4-4】最小花费 | 洛谷 P1576 最小花费

【题目链接】

ybt 1344：【例4-4】最小花费
洛谷 P1576 最小花费

【题目考点】

1. 图论 单源最短路径

时间复杂度：
Dijkstra算法: $O(V^2)$
Dijkstra堆优化算法: $O(V^2)$
SPFA算法:$O(kE)$ ~ $O(VE)$
空间复杂度：
邻接矩阵：$O(V^2)$，
邻接表：$O(V+E)$

【解题思路】

设A有x元要转给B，B收到y元，手续费费率为z，那么有$y=x-x\cdot z\%$
如果已知B要得到y元，A要给B转账x元才能满足要求，则有$x=\frac{y}{1-z\%}$
记$c=\frac{1}{1-z\%}$，称c为费用系数，那么$x=c\cdot y$
回顾Dijkstra与spfa算法中的松弛操作：
u是v的邻接点，边(u,v)的权值为w(u,v)，当前已知从起点v0到v和u的最短路径长度分别为dis[v]与dis[u]。
如果dis[v] > dis[u] + w(u,v)，那么dis[v] = dis[u] + w(u,v)。
该题中，松弛操作与上述方法类似，但又有所不同。
设数组mo，mo[i]表示要使B得到100元，i需要花的最少钱数。已知v和u是邻接点，二者间转账的费用系数为c(u,v)，
原有一条从v转账到B的路径，需要v提供mo[v]元。现在新发现一条从u转账到B的路径，需要u提供mo[u]元，如果从v转账到u，再走从u到B的路径，需要v提供mo[u]*c(u,v)
如果mo[v]大于mo[u]*c(u,v)，说明v先转账到u再通过一条路径转到B，这样的方案可以使v提供更少的费用。
所以松弛操作为：如果mo[v] > mo[u]*c(u,v)，那么mo[v] = mo[u]*c(u,v)
其余操作和原算法相同。

【题解代码】

解法1：Dijkstra算法

#include<bits/stdc++.h>
using namespace std;
#define N 2005
struct Edge
{
    int t;
    double c;//费用系数。x元钱费率z%转账给y,y = x - x*z%，则x = y / (1-z%)。记费用系数c为1/(1-z%)，那么x = c*y 
    Edge(){}
    Edge(int a, double b):t(a),c(b){}
};
vector<Edge> edge[N];
int n, m, a, b;
bool vis[N];
double mo[N];//mo[i]:要使b得到100元，i需要提供的钱数 
void initGraph()
{
    int f, t, z;
    double c;//费用系数 
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> z;
        c = 1 / (1 - z / 100.0);
        edge[f].push_back(Edge(t, c));
        edge[t].push_back(Edge(f, c));
    }
    cin >> a >> b;
}
void dijkstra()
{
    memset(mo, 0x43, sizeof(mo));//将mo各元素设为无穷大
    mo[b] = 100;
    for(int k = 1; k <= n; ++k)
    {
        int u = 0;
        for(int i = 1; i <= n; ++i)
        {
            if(vis[i] == false && (u == 0 || mo[i] < mo[u]))
                u = i;
        }
        vis[u] = true;
        for(int i = 0; i < edge[u].size(); ++i)
        {
            int v = edge[u][i].t;
            double c = edge[u][i].c;
            if(vis[v] == false && mo[v] > mo[u] * c)
                mo[v] = mo[u] * c;
        }
    }
} 
int main()
{
    initGraph();
    dijkstra();
    cout << fixed << setprecision(8) << mo[a];
    return 0; 
}

解法2：SPFA算法

#include<bits/stdc++.h>
using namespace std;
#define N 2005
struct Edge
{
    int t;
    double c;//费用系数。x元钱费率z%转账给y,y = x - x*z%，则x = y / (1-z%)。记费用系数c为1/(1-z%)，那么x = c*y 
    Edge(){}
    Edge(int a, double b):t(a),c(b){}
};
vector<Edge> edge[N];
int n, m, a, b;
bool vis[N];
double mo[N];//mo[i]:要使b得到100元，i需要提供的钱数 
void initGraph()
{
    int f, t, z;
    double c;//费用系数 
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> z;
        c = 1 / (1 - z / 100.0);
        edge[f].push_back(Edge(t, c));
        edge[t].push_back(Edge(f, c));
    }
    cin >> a >> b;
}
void spfa()
{
    memset(mo, 0x43, sizeof(mo));//将mo各元素设为无穷大
    queue<int> que;
    mo[b] = 100;
    que.push(b);
    vis[b] = true;
    while(que.empty() == false)
    {
        int u = que.front();
        que.pop();
        vis[u] = false;
        for(int i = 0; i < edge[u].size(); ++i)
        {
            int v = edge[u][i].t;
            double c = edge[u][i].c;
            if(mo[v] > mo[u] * c)
            {
                mo[v] = mo[u] * c;
                if(vis[v] == false)
                {
                    que.push(v);
                    vis[v] = true;
                }
            }
        }
    }
} 
int main()
{
    initGraph();
    spfa();
    cout << fixed << setprecision(8) << mo[a];
    return 0; 
}

解法3：Dijkstra堆优化算法

#include<bits/stdc++.h>
using namespace std;
#define N 2005
struct Pair
{
    int v;//顶点 
    double d;//距离 
    bool operator < (const Pair &b) const
    {
        return b.d < d;
    }
    Pair(){}
    Pair(int a, double b):v(a),d(b){}
};
struct Edge
{
    int t;
    double c;//费用系数。x元钱费率z%转账给y,y = x - x*z%，则x = y / (1-z%)。记费用系数c为1/(1-z%)，那么x = c*y 
    Edge(){}
    Edge(int a, double b):t(a),c(b){}
};
vector<Edge> edge[N];
int n, m, a, b;
bool vis[N];
double mo[N];//mo[i]:要使b得到100元，i需要提供的钱数 
void initGraph()
{
    int f, t, z;
    double c;//费用系数 
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> z;
        c = 1 / (1 - z / 100.0);
        edge[f].push_back(Edge(t, c));
        edge[t].push_back(Edge(f, c));
    }
    cin >> a >> b;
}
void dijkstra()
{
    priority_queue<Pair> pq;
    memset(mo, 0x43, sizeof(mo));//将mo各元素设为无穷大
    mo[b] = 100;
    pq.push(Pair(b, mo[b]));
    while(pq.empty() == false)
    {
        int u = pq.top().v;
        pq.pop();
        if(vis[u])
            continue;
        vis[u] = true;
        for(int i = 0; i < edge[u].size(); ++i)
        {
            int v = edge[u][i].t;
            double c = edge[u][i].c;
            if(vis[v] == false && mo[v] > mo[u] * c)
            {
                mo[v] = mo[u] * c;
                pq.push(Pair(v, mo[v]));
            }
        }
    }
} 
int main()
{
    initGraph();
    dijkstra();
    cout << fixed << setprecision(8) << mo[a];
    return 0; 
}