(算法提高课)图论-单源最短路径问题3

1126. 最小花费
920. 最优乘车

1126. 最小花费

在 n个人中，某些人的银行账号之间可以互相转账。
这些人之间转账的手续费各不相同。
给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问 A
最少需要多少钱使得转账后 B收到 100 元。
输入格式
第一行输入两个正整数 n,m，分别表示总人数和可以互相转账的人的对数。
以下 m行每行输入三个正整数 x,y,z，表示标号为 x 的人和标号为 y的人之间互相转账需要扣除 z%的手续费 ( z<100 )。
最后一行输入两个正整数 A,B。
数据保证 A与 B之间可以直接或间接地转账。
输出格式
输出 A使得 B到账 100 元最少需要的总费用。
精确到小数点后 8 位。
数据范围
1≤n≤2000
m≤105
输入样例：
3 3
1 2 1
2 3 2
1 3 3
1 3
输出样例：
103.07153164
难度：简单
时/空限制：1s / 64MB
总通过数：10083
总尝试数：21211
来源：《信息学奥赛一本通》

我发现你总是喜欢照搬代码 ，哪一次题目后面和前面完全一样了，不看题直接搬模板真的是…

在本题有$cos{t}_A\ast charge=cos{t}_B=100$
要让$cos{t}_A$有最小，则要求charge最大，换句话来说本题可以看成求最长“距离”

将$dijkstra$算法运用到本题需要理解这个算法的实质，为什么第一次这个点被检索到的时候（每次找距离最小的一个点），它的距离一定是最小的
（注意$dijkstra$算法只能解决边权非负的情况下）
这是因为$dijkstra$算法的本质是贪心；由于确保了每个节点只被访问到一次，且由于边权非负，所以每轮检索到的最短距离是非递减的，因此第一次检索到时，该点距离源点的距离一定是最小的（越加越大）

本题可以运用$dijkstra$方法的原因也是因为贪心可得到结果
由于手续费一定是一个介于0-1直接的数，且本题不采用连加而采用连乘的方法来计算距离，导致距离一定是非递增，或者说的递减的；
此时贪心可以得到最终结果，可以运用$dijkstra$方法

#include<bits/stdc++.h>
using namespace std;
typedef pair<double,int> PDI;
const int N = 2010;
const int M = 200000;

bool vis[N];
int h[N], e[M], ne[M], idx;
double w[M], dis[N];
int n, m, st, ed;

void add(int a, int b, double c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++;
}
//注意本题到底什么样的单源“最短路径”模型
void dijkstra()
{
    //因为是最长路径,此时不需要！将dis数组初始化为INF了
    //由于求最大路径,本题的最长距离是1,也即没有中转的损耗
    dis[st] = 1;  //st * 1 = st;
    priority_queue<PDI> heap;
    heap.push({1, st});
    while(!heap.empty()){   //本题必须采用堆，不然会TLE
        int u = heap.top().second;   heap.pop();
        if(vis[u])  continue;
        vis[u] = true;
        if(u == ed) break;
        for(int i = h[u]; i != -1; i = ne[i]){
            int j = e[i];
            dis[j] = max(dis[j], dis[u] * w[i]);
            heap.push({dis[j], j});
        }
    }
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while(m --){
        int a, b, c;
        cin >> a >> b >> c;
        double t = (100.0 - c) / 100;  
        add(a, b, t);
        add(b, a, t);
    }
    cin >> st >> ed;
    dijkstra();
    double ans = 100.0 / dis[ed];
    printf("%.8f", ans);
    return 0;
}

本题不用堆优化也可以通过，而且时间还少个几十毫秒？

#include<bits/stdc++.h>
using namespace std;
const int N = 2010;

int n, m;
int st, ed;
double g[N][N];
bool vis[N];
double dis[N]; //用来记录两个点之间需要扣除的总的手续费

//确保始终递减，所以贪心可用
double dijkstra()
{
    dis[st] = 1;
    for(int i = 0;i < n;i ++){
        int u = -1;
        for(int j = 1;j <= n;j ++){
            if(!vis[j] && (u == -1 || dis[j] > dis[u])){
                u = j;
            }
        }
        if(u == ed) return dis[u];
        vis[u] = 1;
        for(int j = 1;j <= n;j ++){
            dis[j] = max(dis[j], dis[u] * g[u][j]);
        }
    }
    return dis[ed];
}

int main()
{
    cin >> n >> m;
    while(m --){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        double t = (100.0 - c) / 100;
        g[a][b] = g[b][a] = max(t, g[a][b]);
    }
    cin >> st >> ed;
    double charge = dijkstra();
    
    double ans = 100 / charge;
    printf("%.8f", ans);
    return 0;
}6

---

920. 最优乘车

H城是一个旅游胜地，每年都有成千上万的人前来观光。
为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴士线路。
每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。
一名旅客最近到 H城旅游，他很想去 S公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达 S公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达 S公园。
现在用整数 1,2,…N给 H城的所有的巴士站编号，约定这名旅客所在饭店的巴士站编号为 1，S公园巴士站的编号为 N。
写一个程序，帮助这名旅客寻找一个最优乘车方案，使他在从饭店乘车到 S公园的过程中换乘的次数最少。
输入格式
第一行有两个数字 M 和 N，表示开通了 M条单程巴士线路，总共有 N个车站。
从第二行到第 M+1行依次给出了第 1条到第 M条巴士线路的信息，其中第 i+1行给出的是第 i条巴士线路的信息，从左至右按运行顺序依次给出了该线路上的所有站号，相邻两个站号之间用一个空格隔开。
输出格式
共一行，如果无法乘巴士从饭店到达 S公园，则输出 NO，否则输出最少换乘次数，换乘次数为 0表示不需换车即可到达。
数据范围
1≤M≤100
2≤N≤500
输入样例：
3 7
6 7
4 7 3 6
2 1 3 5
输出样例：
2
难度：中等
时/空限制：1s / 64MB
总通过数：9542
总尝试数：17008
来源：NOI1997

写了一个多小时通过了十个数据但是没有考虑是单程的…也不知道往返的话是不是能过…浅浅 崩溃了

#include<bits/stdc++.h>
using namespace std;
const int N = 510;
const int M = 110;
int n, m;
bool flag[M][N];  //flag[i][j]表示第i辆车可以到达第j个站点(同一行的所有点的距离相同)
vector<int> v[N];  //表示到达第i个节点的巴士有哪些
int dis[N];
bool vis[N], st[M];

void bfs()
{
    memset(dis, -1, sizeof dis);
    queue<int> q;
    q.push(1);
    while(!q.empty()){
        int now = q.front(); q.pop();
        int step = dis[now];
        if(vis[now]) continue;
        vis[now] = 1;
        for(int i = 0;i < v[now].size();i ++){
            int bus = v[now][i];
            if(st[bus]) continue;  //保证每个bus也只被访问一次
            st[bus] = 1;
            cout << "bus: " << bus << endl;
            for(int j = 1;j <= n;j ++){
                if(flag[bus][j] && dis[j] == -1){  //保证每个dis只被更新一次
                    dis[j] = step + 1;
                    if(j == n){
                        return;
                    }
                    q.push(j);
                }
            }
        }
    }

}

int main()
{
    cin >> m >> n;
    string input;
    getline(cin, input);
    for(int i = 1;i <= m;i ++){
        getline(cin, input);
        stringstream ss;
        ss << input;
        int node;
        while(ss >> node){
            flag[i][node] = 1;
            v[node].push_back(i);

        }
    }
    //按照这个定义的话同一辆巴士上的所有点的距离是相同的，有点从点变成点集的感觉
    //如何搜索，如何保证每个点第一次被搜索的时候距离就是最小的
    bfs();
    if(dis[n] == -1) puts("NO");
    else cout << dis[n];
    return 0;
}

优化代码：
本题要求的是换乘次数，而换乘次数 = 乘车次数 - 1；
关于乘车次数，将乘车次数转化为距离问题，同一辆BUS上的站点的距离是1（乘车一次即可到达）
所以在$g[N][N]$这个边权存放数组中，每一辆公交车的每一个站点，与其后面的所有站点，都有一条边权为1的有向边（难点是对这个信息的转化，如何通过BUS这个载体把边权抽象出来）

//其实单程车和双程往返车就是有向图和无向图之间的关系
//在本题中难点是什么是距离
//其实有想到过,擦边了但是没有把这个想法具象化
#include<bits/stdc++.h>
using namespace std;
const int N = 510;
const int INF = 0x3f;
const int MAX = 0x3f3f3f3f;
int n, m;
int g[N][N];
int dis[N];  //记录从1站点到其他站点去，需要乘坐的公交车数量
int stop[N];   //记录下每辆公交车依次经停的站点,同一辆公交车上站点,前面的点到它之后的每一个站点都有条边权为1的有向边，表示单向可达
//因为距离恒为1，所以可以使用BFS，按层搜索
void bfs()
{
    memset(dis, INF, sizeof dis);
    dis[1] = 0;
    queue<int> q;
    q.push(1);
    while(!q.empty()){
        int now = q.front(); q.pop();
        for(int i = 1;i <= n;i ++){
            //g[now][i]保证了它们在一辆公交车上
            if(g[now][i] && dis[i] > dis[now] + 1){
                dis[i] = dis[now] + 1;
                q.push(i);
            }
        }
    }
}
int main()
{
    cin >> m >> n;
    string input;
    getline(cin, input);
    while(m --){
        getline(cin, input);
        stringstream ss(input);
        int cnt = 0, t;
        while(ss >> t) stop[cnt ++] = t;
        for(int i = 0;i < cnt; i ++){
            for(int j = i + 1;j < cnt;j ++){
                g[stop[i]][stop[j]] = 1;  //第I个站点到第J个站点的边权为1
            }
        }
    }
    //按照这个定义的话同一辆巴士上的所有点的距离是相同的，有点从点变成点集的感觉
    //如何搜索，如何保证每个点第一次被搜索的时候距离就是最小的
    bfs();
    if(dis[n] == MAX) puts("NO");
    else cout << dis[n] - 1;  //换乘次数等于搭乘次数 - 1;
    return 0;
}