最短路 - 九度 OJ 1447

博客介绍了如何解决九度 OJ 1447 题目中的最短路径问题,通过Floyd算法和Dijkstra算法进行详细讲解。Floyd算法具有O(N^3)的时间复杂度,适合小规模图的全源最短路问题,而Dijkstra算法适用于邻接链表或矩阵,逐个确定节点的最短路径。

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

最短路 - 九度 OJ 1447

题目

时间限制:1 秒 内存限制:128 兆 特殊判题:否
题目描述:
在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的! 所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?
输入:
输入包括多组数据。每组数据第一行是两个整数N、 M (N<=100,M<=10000), N 表示成都的大街上有几个路口,标号为 1 的路口是商店所在地,标号为 N 的 路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来 M 行,每行包括 3 个整数 A,B,C(1<=A,B<=N,1<=C<=1000),表示在路口 A 与路口 B 之间有一条路,我们的工作人员需要 C 分钟的时间走过这条路。输入 保证至少存在1条商店到赛场的路线。
当输入为两个0时,输入结束。
输出:
对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间。
样例输入:
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
样例输出:
3
2

Floyd算法

首先分析复杂度,Floyd算法主要包括 一个三重循环,每重循环的循环次数均是N,这样 Floyd算法的时间复杂度为O (N^3),空间复杂度为O(N^2),其中N均为图中结点的个数。在本题中N最大值为100,N^3的时间复杂度尚在可以接受的范围内。

#include <stdio.h>

int ans[101][101];//二维数组,其初始值即为该图的邻接矩阵

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0 && m==0)break;

        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                ans[i][j]=-1;//对邻接矩阵初始化,用-1代表无穷
            }
            ans[i][i]=0;//自己到自己的路径长度设为0
        }

        while(m--){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            ans[a][b]=ans[b][a]=c;
            //对邻接矩阵赋值,由于是无向图,该赋值操作要进行两次
        }

        for(int k=1;k<=n;k++){
            //k从1到n循环,依次代表允许经过的中间节点编号小于等于k
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    //遍历所有ans[i][j],判断其值保持原值还是将要被更新
                    if(ans[i][k]==-1||ans[k][j]==-1)continue;
                    //若两值中有一个值为无穷,则ans[i][j]不能由于经过节点k而被更新,跳过循环,保持原值

                    if(ans[i][j]==-1||ans[i][k]+ans[k][j]<ans[i][j])
                        ans[i][j]=ans[i][k]+ans[k][j];
                    //当由于经过k可以获得更短的最短路径时,更新该值
                }
            }
        }
        printf("%d\n",ans[1][n]);//循环结束后输出答案
    }
    return 0;
}

总结 Floyd 算法的特点:
首先,牢记其时间复杂度为 O(N^3),所以在大部分机试题的时间允许范围内,它要求被求解图的大小不大于 200 个结点,若超过该数字该算法很可能因为效率不够高而被判超时。
第二,Floyd 算法利用一个二维矩阵来进行相关运算,所以当图使用邻接矩阵表示时更为方便。若原图并非由邻接矩阵给出时我们设法将其转换,注意当两个结点间有多余一条边时,我们选择长度最小的边权值存入邻接矩阵。
第三,当 Floyd 算法完成后,图中所有结点之间的最短路都将被确定。所以,其较适用于要求询问多个结点对之间的最短路径长度问题,即全源最短路问题。

Dijstra 算法

#include <stdio.h>
#include <vector>

using namespace std;

struct E{//邻接链表中的链表元素结构体
    int next;//代表直接相邻的结点
    int c;//代表该边的权值(长度)
};

vector<E> edge[101];//邻接链表
bool mark[101];
//标记,当mark[j]为true时表示结点j的最短路径长度已经得到,
//该结点已经加入集合K
int Dis[101];
//距离向量,当mark[i]为true时,表示已得的最短路径长度;
//否则,表示所有从结点1出发,经过已知的最短路径达到集合K中的某结点
//再经过一条边到达结点i的路径中最短路径的距离

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        if(n==0 && m==0)break;
        for(int i=1;i<=n;i++){
            edge[i].clear();//初始化邻接链表
        }
        while(m--){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            E tmp;
            tmp.c=c;
            tmp.next=b;
            edge[a].push_back(tmp);
            tmp.next=a;
            edge[b].push_back(tmp);
            //将邻接信息加入邻接链表,由于原图为无向图,
            //所以每条边信息都要添加到其两个顶点的两条单链表中
        }

        for(int i=1;i<=n;i++){//初始化
            Dis[i]=-1;//所有距离为-1,即不可达
            mark[i]=false;//所有结点不属于集合K
        }

        Dis[1]=0;//得到最近的点为结点1,长度为0
        mark[1]=true;//将结点1加入集合K
        int newP=1;//集合K中新加入的点为结点1

        for(int i=1;i<n;i++){
            //循环n-1次,按照最短路径递增的顺序确定其他n-1个点的最短路径长度
            for(int j=0;j<edge[newP].size();j++){
                //遍历与该新加入集合K中的结点直接相邻的边
                int t=edge[newP][j].next;//该边的另一个结点
                int c=edge[newP][j].c;//该边的长度
                if(mark[t]==true)continue;
                //若另一个结点也属于集合K,则跳过
                if(Dis[t]==-1 || Dis[t]>Dis[newP]+c){
                    //若该结点尚不可达,或者该结点从新加入的结点经过一条边到达时比以往距离更短
                    Dis[t]=Dis[newP]+c;//更新其距离信息
                }
            }

            int min=123123123;//最小值初始化为一个大整数,为找最小值做准备
            for(int j=1;j<=n;j++){
                //遍历所有结点
                if(mark[j]==true)continue;//若其属于集合K则跳过
                if(Dis[j]==-1)continue;//若该结点仍不可达则跳过
                if(Dis[j]<min){
                    //若该结点经由结点1至集合K中的某点在
                    //经过一条边到达时距离小于当前最小值
                    min=Dis[j];//更新其为最小值
                    newP=j;//新加入的点暂定为该点
                }
            }
            mark[newP]=true;
            //将新加入的点加入集合K,Dis[newP]虽然数值不变,但意义发生变化
            //由所有经过集合K中的结点再经过一条边到达时的距离中的最小值 变为
            //从结点1到结点newP的最短距离
        }
        printf("%d\n",Dis[n]);//输出
    }
    return 0;
}

如代码所示,我们用 mark[i]的值来确定结点 i 的最短路径是否已经被确定,并根据结点 i 是否属于集合 K,Dis[i]中的数字体现出不同的意义。当结点 i 属于集合 K 时,Dis[i]代表结点 i 已经被确定的最短路径长度;相反,若结点 i 不属于集合 K,那么 Dis[i]表示,所有从结点 1 出发先按照某条最短路径到达某已经在集合 K 中的结点,并由该结点经过一条边到达结点 i 路径中的最短距离。
每当有新的结点 newP 加入集合 K 时,我们标记 mark[newP]为 true,同时计算与结点newP 直接相邻的非集合 K 中的结点,经过由结点 1 经过最短路径到达 newP,再由 newP 经过一条边到达该结点的距离,是否比由集合 K 中其它结点经过一条边到达时更短,若更短则修改 Dis 数组中相关的值,否则不改变 Dis 中的值。当所有与 newP 相邻的点修改完成后,我们遍历 Dis 数组中不属于集合 K 的结点,找到距离最短的那个,该结点即为下一个最短距离被确定的点,将该点加入集合K,并使 newP 等于该结点的编号。当所有点的最短路径都确定后,Dis[n]中的值
即为由结点 1 到达其它所有结点的最短路径长度。
该代码中,使用了邻接链表保存图信息。由此可见,Dijstra 算法很好的支持邻接链表,但同时它也可以被应用于邻接矩阵。这里使用邻接链表,是为了更详细的了解用 vector 模拟邻接链表的方法。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值