三道最短路例题（Frogger， Heavy Transportation, find the longest of the shortest）

最新推荐文章于 2022-08-05 18:55:04 发布

Xuhx&

最新推荐文章于 2022-08-05 18:55:04 发布

阅读量183

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/m0_51508220/article/details/113759122

版权

笔记专栏收录该内容

51 篇文章 1 订阅

订阅专栏

最短路做题总结1

细节
find the longest of the shortest
dijkstra的变形

细节

存储每条路间的长度时，要注意存储这两点间最短的（可能会重复录入，比如 1 2 3； 1 2 4） 1 2两点间的距离，我们存储的应该是 3. 因此我们应该这样 cin >> a >> b >> c g[a][b] = min(g[a][b], c); g[b][a] = g[a][b]
多组输入，不断更新 book标记数组，初始化g[][]原数组。
题目描述说：输入路径后，最后一行两个数， s， t，起点s 。我们要看的也只是这一组。开始时，我用的floyd算法，但仔细一想，我们用dijkstra算法也可，在写该函数时，只需要将 dis[x] = 0, 即可。和模板题套路一样。
注意题目所说的编号n ，和m条路径输入的顺序，因为这个这个我wa了好几回

find the longest of the shortest

问题描述

有一城市，这个城市有n个地点和m条连接他们的路，点的编号是从1到n，小X住在1，他想去n。
但是最近正在维修公路，也就是说这m条路有且只有一条是坏的，但是小X不知道是哪一条，一条很关键的路坏了路程就会增加很多，所以小X想知道从1到n 最坏情况* 下的路程。

思路分析

最直接的想法，就是枚举每一条给的路径，把这条路径“删掉"，删掉可以把邻接矩阵对应的边赋值为INF，然后依次求最短路。
但是所有的边数太多了，有1000*999/2条，不用想了肯定是超时的。所以选择删哪些边是最重要的。
只需要先求一次最短路，记录好路径，然后枚举删除这条路径上的边，再求最短路，所有最短路中最大的那个就是答案。这样最多就只需要删除n次就可以了。
为什么只要枚举的是最短路上的边就行了呢？很简单，如果枚举的是其他边，那么将会毫无影响，再次进行最短路算法时，得出的还是和原来的最短路一样。记录路径的方法是在松弛的时候用一个数组pre记录。
我们整一个优化：在没有加入集合T的点中如果最小点是 0x3f3f3f3f时，我们直接返回即可
我们这里e[]记录的原数组，即两点间原始距离， p[]记录的最短路路径。

代码实现

关于dijkatra算法的实现：
初始化dis数组，全部为 0x3f。
我们找着距离原始点1最近的点 t 后，在用该点为中转点更新其他点 v 时，就要记录路径。 p[v] = j; j的下一点是v， p[v] 就是v的上一点。通过不断的更新，最后即可存储一条完整的最短路径
我们在第一次调用dijkstra算法（在不去掉任何一个点的情况下）需要记录路径，但在枚举去的点后，再次调用时不能记录更新p[]了，这时我们可以通过给函数传递的参数分开这两种情况。

代码

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1010, inf = 0x3f3f3f3f;
int  book[N];
int e[N][N], dis[N], p[N];
int n, m, minn;

void dijkstra(int x){
    memset(dis, inf, sizeof(dis));
    memset(book, 0, sizeof(book));
    dis[1] = 0;
    int t;
    for(int i = 1; i <= n; i ++){
        int minn = inf;
        int t;
        for(int j = 1; j <= n; j ++){
            if(!book[j] && dis[j] < minn){
                minn = dis[j];
                t = j;
            }
        }
        if(minn == inf) return ;
        book[t] = 1;
        for(int v = 1; v <= n; v ++){
            if(!book[v] && dis[v] > dis[t] + e[t][v]){
                dis[v] = dis[t] + e[t][v];
                if(x){
                    p[v] = t; //记录j点的下一个点是v， 那么v的上一个点就是j;

                }
            }
        }
    }
    return ;
}

int main(void){
    while(cin >> n >> m){
        for(int i = 0; i <= n; i ++){
            for(int j = 0; j <= n; j ++){
                if(i == j) e[i][j] = 0;
                else e[i][j] = inf;
            }
        }
        memset(p, 0, sizeof(p));
        while(m --){
            int a, b, w;
            scanf("%d%d%d", &a, &b, &w);
            e[a][b] = min(e[a][b], w);
            e[b][a] = e[a][b];
        }
        dijkstra(1);
        int maxx = dis[n];
        for(int i = n; i != 1; i = p[i]){
            int q = e[i][p[i]];
            e[i][p[i]] = e[p[i]][i] = inf;
            dijkstra(0);
            maxx = max(maxx, dis[n]);
            e[i][p[i]] = e[p[i]][i] = q;
        }
        cout << maxx << endl;
    }
    return 0;
}

dijkstra的变形

两个变形简单说明

问题一：从一个点到另一个点，在所有行的通的路中，找到每条路中最长的那条边，在所有的路的最长边中最短的那条边就是所求。
问题二：从1到点n，很多路径，每条路径都有一个最小的权值（一条路中我们的承重量是最小值），求这些权值中的最大值

分析

明确“松弛的目的”
（1）刚接触最短路算法时，模板题松弛目的：把原点能到达的点的权值变到最小，（所以我们找到距离原点最短的点，并以此为中转点）；
（2）在问题一中，松弛目的：把原点能到的点的权值变成可行的最小值（所以我们找到距离原点最小的点，通过该点来试图缩短原点到另外点的权值（并非两点间距离，注意所求问题））
（3）在问题二中，松弛目的：把原点能到的点的权值变成可行的最大值，（所以我们找到原点能到的点的权值最大的，这个点一定是个定值了）

dis[i]数组含义
（1）模板题的含义：原点到 i 点的最短距离
（2）问题一：起始点到当前点的最小跳距离（这个距离是最优路径中最长的那条边），我们不断更新，维护dis数组含义
（3）问题二：起始点到当前点的最大承重量（这个承重量是最优路径中最小的权值）

Frogger

题目大意

从一个点到另一个点，在所有行的通的路中，找到每条路最长的那条边，在取得的所有路的最长边中最短的那条边就是所求。

Dijkstra代码

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int N = 210;
int vis[N];
double d[N], w[N][N];
int n;
struct f{
    double x, y;
}point[N];

void dijkstra(){
    for(int i = 1; i <= n; i ++){
        d[i] = w[1][i];
        vis[i] = 0;
    }
    vis[1] = 1;
    d[1] = 0;
    for(int i = 1; i <= n; i ++){
        int minn = 1e9, x = -1;
        for(int j = 1; j <= n; j ++){
            if(!vis[j] && d[j] < minn) minn = d[x = j];
        }
        if(x != -1){
            vis[x] = 1;
            for(int j = 1; j <= n; j ++){
                if(!vis[j] && d[j] > max(d[x], w[x][j])){
                    d[j] = max(d[x], w[x][j]);
                }
            }
        }
    }


}

int main(void){
    int  k = 0;
    while(1){
        scanf("%d", &n);
        k ++;
        if(n == 0) return 0;
        for(int i = 1; i <= n; i ++){
            scanf("%lf%lf", &point[i].x, &point[i].y);
        }
        for(int i = 1; i <= n; i ++){
            for(int j = i + 1; j <= n; j ++){
                w[i][j] = w[j][i] = sqrt((point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y));
            }
        }
        dijkstra();
        printf("Scenario #%d\n", k);
        printf("Frog Distance = %.3f\n\n", d[2]);
    }
}

Floyd算法代码

#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
struct f{
    double x, y;
}point[205];
double path[201][201];
int k;
int main(void){
    int n;
    while(1){
        scanf("%d", &n);
        k ++;
        if(n == 0) return 0;
        for(int i = 0; i < n; i ++){
            scanf("%lf%lf", &point[i].x, &point[i].y);
        }
        for(int i = 0; i < n - 1; i ++){
            for(int j = i + 1; j < n; j ++){
                path[j][i] = path[i][j] = sqrt( (point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y));
            }
        }
        for(int k = 0; k < n; k ++){ //作为转折点的点
            for(int i = 0; i < n - 1; i ++){
                for(int j = i + 1; j < n; j ++){
                    if(path[i][k] < path[i][j] && path[k][j] < path[i][j]){
                        if(path[i][k] < path[k][j]){
                            path[i][j] = path[j][i] = path[k][j];
                        }
                        else path[i][j] = path[j][i] = path[i][k];
                    }
                }
            }
        }
        printf("Scenario #%d\n", k);
        printf("Frog Distance = %.3f\n", path[0][1]);
        cout << endl;
    }
}

Heavy Transportation

题目大意

从1到点n，很多路径，每条路径都有一个最小的权值（一条路中我们的承重量是最小值），求这些权值中的最大值

关于更新数组时取值的解释

在这里插入图片描述
如上示意图，我们要更新d[j],当他小于其他两条的权值的较小值时，我们才用更新（避免铁路被压坏）

代码

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int M = 1e9;
const int N = 1010;
int d[N], vis[N], w[N][N];
int n, m;

void dijkstra(){
    for(int i = 1; i <= n; i ++){
        d[i] = w[1][i];
        vis[i] = 0;
    }
    vis[1] = 1;
    for(int i = 1; i <= n; i ++){
        int maxx = -1, x = -1;
        for(int j = 1; j <= n; j ++){
            if(!vis[j] && d[j] > maxx) maxx = d[x = j];
        }
        if(x != -1){
            vis[x] = 1;
            for(int j = 1; j <= n; j ++){
                if(!vis[j] && d[j] < min(d[x], w[x][j])){
                    d[j] = min(d[x], w[x][j]);
                }
            }
        }
    }


}

int main(void){
    int T, t = 1;
    cin >> T;
    while(T --){
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i ++){
            for(int j = 1; j <= n; j ++){
                if(i == j) w[i][j] = 0;
                else w[i][j] = -1;
            }
        }
        for(int i = 1; i <= m; i ++){
            int x, y, z;
            scanf("%d%d%d", &x, &y, &z);
            if(w[x][y] < z) w[x][y] = w[y][x] = z;
        }
        dijkstra();
        printf("Scenario #%d:\n%d\n\n", t, d[n]);
        t ++;
    }
    return 0;
}

Xuhx&

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
三道最短路例题（Frogger， Heavy Transportation, find the longest of the shortest）

最短路做题总结1细节find the longest of the shortest问题描述细节存储每条路间的长度时，要注意存储这两点间最短的（可能会重复录入，比如 1 2 3； 1 2 4） 1 2两点间的距离，我们存储的应该是 3. 因此我们应该这样 cin >> a >> b >> c g[a][b] = min(g[a][b], c); g[b][a] = g[a][b]find the longest of the shortest问题描述..
复制链接

扫一扫