NYOJ 1248 海岛争霸（利用最短路径可解）

最新推荐文章于 2020-04-01 19:27:17 发布

Merry_hj

最新推荐文章于 2020-04-01 19:27:17 发布

阅读量553

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/Merry_hj/article/details/71108319

本文介绍了一款名为“海岛争霸”的游戏背景下的最短路径算法应用案例，重点讲解了使用Floyd算法和Dijkstra算法来解决游戏中寻找岛屿间最低危险度路径的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

海岛争霸

时间限制：1000 ms | 内存限制：65535 KB

难度：3

描述

神秘的海洋，惊险的探险之路，打捞海底宝藏，激烈的海战，海盗劫富等等。加勒比海盗，你知道吧？杰克船长驾驶着自己的的战船黑珍珠1号要征服各个海岛的海盜，最后成为海盗王。这是一个由海洋、岛屿和海盗组成的危险世界。杰克船长准备从自己所占领的岛屿A开始征程，逐个去占领每一个岛屿。面对危险重重的海洋与诡谲的对手，如何凭借智慧与运气，建立起一个强大的海盗帝国。

杰克船长手头有一张整个海域的海图，上面详细地记录了各个海屿的位置，以及海屿之间的通航路线。但他发现，有的航海路线太危险了，杰克船长的战船很难直接通过，他必须想方设法绕道航行；还有的岛屿根本到达不了。

杰克船长现在想把航行的危险程度降到最小。具体地来说，就是杰克船长提出若干个询问，他想知道从岛屿A 到岛屿B 有没有行驶航线，若有的话，所经过的航线，危险程度最小可能是多少。

输入

第1行: N M 表示有N个岛屿，M条直航路线
第2~M+1行： A B V 表示从岛屿A到岛屿B的航海路线的危险程度值为V。
接下面一行： Q 表示询问的次数。
之后有Q个行： A B 表示询问从岛屿A 到岛屿B 所经过的航线，危险程度最小值
1<N≤100 0<M≤500 1≤ Q≤20 0 < V≤1000，
所有数据都是正整数。输入数据之间有一个空格。

输出

对于每个询问，输出占一行，一个整数，表示从岛屿A 到岛屿B 所经过的航线，危险程度最小值；若从岛屿A 无法到达岛屿B，则输出-1。

样例输入

样例输出

5 5 -1 5

-1

解题思路：开始没有看懂题意，以为是求最短路径的最大权坑了我好久，最后理解题意之后才知道是找所有a到b的路径中每条路径，最后再找所有路径的最大权的最小值，Floyd的变形，原来dist[i][j]保存的是i到j的最短路中的最大权

#include <iostream>
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int Map[205][205];
int dist[205][205];
int Floyd()
{

    memset(dist,INF,sizeof(dist));
    for(int i=0;i<=n;i++)
        dist[i][i]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            dist[i][j] = Map[i][j];
        }
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j) continue;
                ///dist[i][j] = min(dist[i][j], max(dist[i][k], dist[k][j]));///这个语句的作用于下面相同
                int pos = dist[i][k];
                if(pos < dist[k][j])
                    pos = dist[k][j];
                if(dist[i][j]>pos)
                {
                    dist[i][j] = pos;
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int a,b,c;
        memset(Map,INF,sizeof(Map));
        for(int i=1;i<=n;i++)   Map[i][i]=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            Map[a][b]=min(Map[a][b],c);///输入地图并去重边
            Map[b][a]=Map[a][b];
        }
        Floyd();
        int k;scanf("%d",&k);
        for(int i=0;i<k;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            if(dist[x][y]<INF)
                printf("%d\n",dist[x][y]);
            else
                printf("-1\n");
        }
    }
    return 0;
}

解法2：dijkstra

#include <iostream>
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f

using namespace std;
int n,m;
int Map[205][205];
int dijkstra(int x,int y)
{
    int maxv[205],vis[205],Mindist,k;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        maxv[i]=Map[x][i];
    }
    vis[x]=1;
    for(int i=1;i<=n;i++)
    {
        Mindist = INF;
        for(int j=1;j<=n;j++)
        {
            if(vis[j]==0&&maxv[j]<Mindist)
            {
                Mindist = maxv[j];
                k=j;
            }
        }
        if(Mindist ==  INF) break;
        vis[k]=1;
        for(int j=1;j<=n;j++)
        {
            if(vis[j]==0 && (max(maxv[k], Map[k][j])) < maxv[j])
            {
                maxv[j] = max(maxv[k], Map[k][j]);
            }
        }
    }
    if(maxv[y]<INF)
        return maxv[y];
    else
        return -1;
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int a,b,c;
        memset(Map,INF,sizeof(Map));
        for(int i=1;i<=n;i++)   Map[i][i]=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            Map[a][b]=min(Map[a][b],c);
            Map[b][a]=Map[a][b];
        }
        int k;scanf("%d",&k);
        for(int i=0;i<k;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            printf("%d\n", dijkstra(x, y));
        }
    }
    return 0;
}

Floyd 求最短路径

#include <iostream>
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int Map[205][205];
int dist[205][205],path[205][205];
int Floyd()
{

    memset(dist,INF,sizeof(dist));
    for(int i=0;i<=n;i++)
        dist[i][i]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            dist[i][j] = Map[i][j];
            if(i!=j&&Map[i][j]<INF)
                path[i][j]=i;
            else
                path[i][j]=-1;
        }
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j) continue;
                if(dist[i][j]>dist[i][k]+dist[k][j])
                {
                    dist[i][j] = dist[i][k]+dist[k][j];
                    path[i][j] = path[k][j];
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int a,b,c;
        memset(Map,INF,sizeof(Map));
        for(int i=1;i<=n;i++)   Map[i][i]=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            Map[a][b]=min(Map[a][b],c);
            Map[b][a]=Map[a][b];
        }
        Floyd();
        int k;scanf("%d",&k);
        for(int i=0;i<k;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            if(dist[x][y]<INF)
                printf("%d\n",dist[x][y]);
            else
                printf("-1\n");
        }
    }
    return 0;
}