最短路题解

tuoluoo

已于 2023-12-24 17:29:09 修改

阅读量508

点赞数

分类专栏：算法文章标签： c++ 算法数据结构

于 2022-02-14 19:26:03 首次发布

本文链接：https://blog.csdn.net/tuoluoo/article/details/122930518

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

图：顶点与边的集合。表示为G（V，E）。G表示图，V表示顶点个数(即图中的元素），E表示边的数；图中一定有顶点，边可以没有，任意两个顶点都可能有关系

floyd算法：感觉像是一种动态规划，建立一个二维数组，用来表示两点间的最短路径值，开始的时候是初始化的值，用三个循环，不断判断通过其他顶点的参与，是否有最短路径可取，更新两点间的最短距离

基本代码

#include<bits/stdc++.h>.
using namespace std;
int main()
{
    int e[10][10];//所需要构造的最短路径图
    int maxx=9999999;//表示无穷大
    int n,m;//表示顶点和边的数
    cin>>n>>m;
    //初始化
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                e[i][j]=0;//自身到自身的距离始终为0
            else
                e[i][j]=maxx;
        }
    }
    //读入边
    int t1,t2,t3;//t1是起始点，t2是到达点,t3是距离
    for(int i=1;i<=m;i++)
    {
        cin>>t1>>t2>>t3;
        e[t1][t2]=t3;//构造最短路径图
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[i][j]>e[i][k]+e[k][j])//不断寻找最短路径，然后更新数值
                    e[i][j]=e[i][k]+e[k][j];
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        cout<<e[i][j]<<" ";
        cout<<endl;
    }
}

dijkstra算法：一般用于由一个点出发，找到这个点到其他各点的距离的情况，所以每次我们每次都要找到一个出发点最近的一个顶点，然后以该顶点为中心进行扩展，最终得到最短路径图

基本代码

#include<bits/stdc++.h>
using namespace std;
int e[10001][10001];//用于存储顶点间的关系
int dis[10001];//用于存储源点到其他各点的最短距离
bool book[10001];//用于标记已知最短路径和未知最短路径
int maxx=2147483647;//表示不能到达时候
int main()
{
    int n,m,s,t1,t2,t3;
    cin>>n>>m>>s;
    //初始化
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                e[i][j]=0;
                else
                    e[i][j]=maxx;
        }
    }
    //读入边
    for(int i=1;i<=m;i++)
    {
        cin>>t1>>t2>>t3;
        e[t1][t2]=t3;
    }
    //初始化dis数组
    for(int i=1;i<=n;i++)
        dis[i]=e[s][i];
    //初始化book数组
    for(int i=1;i<=n;i++)
        book[i]=false;
    book[s]=true;
    int u;
    for(int i=1;i<=n-1;i++)//计算源点到n-1个点的权
    {
        //找到离源点最近的点
        int minn=maxx;
        for(int j=1;j<=n;j++)
        {
            if(book[j]==false&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
        book[u]=1;//确定此点是离源点最近的点，然后从这点开始发散
        for(int v=1;v<=n;v++)
        {
            if(e[u][v]<maxx)//找到这个点可连接的其他点
            {
                if(dis[v]>dis[u]+e[u][v])//判断是否更新数据
                    dis[v]=dis[u]+e[u][v];
            }
        }
    }
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
    return 0;
}

前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了.

基本代码

struct Edge
{
     int next;//下一个同起点的结构体下标
     int to;//终点
     int w;//权
};
int head[10000];//head初始化为-1，表示此时没有同起点的顶点
void add(int u,int v,int w)//u为起点，v为终点，w为权，cnt初始化为1
{
    edge[cnt].w = w;
    edge[cnt].to = v;
    edge[cnt].next = head[u];//表明同起点的有无情况
    head[u] = cnt;//把下标和付给这个起点的head，建立关系
    cnt++；
}

这个题的大致题意就是给出图的两点间的值，然后求最短路径值。用的是floyd算法，直接构造一个最短路径图，然后输出图（1，n）的值就好

#include<bits/stdc++.h>.
using namespace std;
int main()
{
    int e[300][300];//所需要构造的最短路径图
    int maxx=9999999;//表示无穷大
    int n,t;
    cin>>n;
    //初始化
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                e[i][j]=0;//自身到自身的距离始终为0
            else
                e[i][j]=maxx;//表示此路暂时不通
        }
    }
      for(int i=1;i<n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            cin>>t;
            e[i][j]=t;//构造最短路径图
        }
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[i][j]>e[i][k]+e[k][j])//不断寻找最短路径，然后更新数值
                    e[i][j]=e[i][k]+e[k][j];
            }
        }
    }
    cout<<e[1][n];
}

奇了巴怪了这个题，开始看到这个第的时候我用了搜索，逐个枚举每个顶点，然后搜索这个顶点是不是用其他的到达方式，是的话就加一，然后再输出依旧为一的点，但是还是有三个测试点没分，于是我又采用其他方法

我们直接枚举每个铁路被炸的情况，通过并查集连接其他的铁路,此时如果是keyroad的话，这城市就不会连成一整块，也就是说存在有两个城市不相连的情况，这时我们只需要判断两两连续城市是否有相同的老大就行

#include<bits/stdc++.h>
using namespace std;
struct ma//关系结构体
{
    int x;
    int y;
}a[6000];
int n,m,p[200];
bool pai(ma c,ma d)//结构体排序
{
    if (c.x==d.x)//前一个相等时比较后一个
        return c.y<d.y;
    else
        return c.x<d.x;
}
int findd(int q)//找老大
{
        while(p[q]!=q)
            q=p[q];
      return q;
}
void join(int e,int r)//并查集
{
    int fx=findd(e),fy=findd(r);
    if(fx!=fy)
        p[fx]=fy;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>a[i].x>>a[i].y;
        if(a[i].x>a[i].y)//把小的放前面，方便排序
            swap(a[i].x,a[i].y);
    }
    sort(a+1,a+1+m,pai);//方便输出
    for(int i=1;i<=m;i++)//枚举每条铁路
    {
        for(int j=1;j<=n;j++)
            p[j]=j;//初始化
    for(int j=1;j<=m;j++)
    {
        if(i!=j)
        join(a[j].x,a[j].y);
    }
    for(int j=2;j<=n;j++)
    {
        if(findd(p[j])!=findd(p[j-1]))//此时如果是keyroad的话，这城市就不会连成一整块，也就是说存在有两个城市不相连的情况，这时我们只需要判断两两城市是否有相同的老大就行
        {
            cout<<a[i].x<<" "<<a[i].y<<endl;
            break;
        }
    }
    }
return 0;
}

这个题目的大致意思是给出你一张有向图所有边的权，然后你根据它给的路线找到一条最短路径，我优先考虑的是floyd算法，毕竟这个代码最简单

然后我们根据给出数据构建一张最短路径图，然后沿着路线将权相加就可以了

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int maxx=100009;
    int mp[200][200],road[10005],n,m,sum=0;
    cin>>n>>m;
    for(int i=1; i<=m; i++)
        cin>>road[i];//将数据存入路线数组
    //初始化
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
            mp[i][j]=maxx;
    }
    for(int i=1; i<=n; i++)//构建图
        for(int j=1; j<=n; j++)
            cin>>mp[i][j];
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(mp[i][j]>mp[i][k]+mp[k][j])//不断寻找最短路径，然后更新数值
                    mp[i][j]=mp[i][k]+mp[k][j];
            }
        }
    }
    for(int i=1;i<m;i++)
    {
        sum=sum+mp[road[i]][road[i+1]];//此时最短路径图已经更新好了，我们只需要沿着路线将权相加就行
    }
    cout<<sum;
}

这个题的数据范围较大，如果构建二维数组存图的话就会数据空间超限，所以我们要运用前所讲的链式前向星

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int to;//终点
    int v;//权
    int next;//下一个同起点的结构体下标
} edge[500005];
int maxx=2147483647;//记为无穷大
int book[10005];//用于标记已知最短路径和未知最短路径
int dis[10005];//用于存储源点到其他各点的最短距离
int head[10005];//用于存储同起点边的
int cnt=1;//作为结构体下标
int n,m,s;
// 链式前向星
void uni(int x,int y,int z)
{
    edge[cnt].to=y;
    edge[cnt].v=z;
    edge[cnt].next=head[x];
    head[x]=cnt;
    cnt++;

}
void dijkstra()
{

    int u=s;//从起点开始
    for(int i=1;i<=n-1;i++)//计算源点到n-1个点的权
    {
        book[u]=1;//标记扩展点
        for(int k=head[u];k!=-1;k=edge[k].next)
        {
            int a=u,b=edge[k].to,w=edge[k].v;
            if(dis[b]>dis[a]+w)
                dis[b]=dis[a]+w;
        }
        //找到离源点最近的点
        int minn=maxx;
        for(int j=1;j<=n;j++)
        {
            if(book[j]==0&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    //初始化head数组和dis数组
    for(int i=1;i<=n;i++)
    {
        head[i]=-1;//表示此路不通
        dis[i]=maxx;
    }
    dis[s]=0;
    //读入边
    for(int i=1;i<=m;i++)
    {
        int t1,t2,t3;
        cin>>t1>>t2>>t3;
        uni(t1,t2,t3);//建造链式前向星
    }
    //初始化book数组
    for(int i=1;i<=n;i++)
        book[i]=0;
   dijkstra();
   for(int i=1;i<=n;i++)
    cout<<dis[i]<<" ";
}

一个dijkstra模板题，直接套用模板就行，有一点要注意就是因为是无向图，所以再构建图的时候，输入边时要使两个顶点互通

#include<bits/stdc++.h>
using namespace std;
int e[2505][2505];//用于存储顶点间的关系
int dis[10001];//用于存储源点到其他各点的最短距离
int book[10001];//用于标记已知最短路径和未知最短路径
int maxx=2e7;//表示不能到达时候
int main()
{
    int n,m,s,t1,t2,t3,t;
    cin>>n>>m>>s>>t;
    //初始化
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            if(i==j)
                e[i][j]=0;
            else
                e[i][j]=maxx;
        }
    }
    //读入边
    for(int i=1; i<=m; i++)
    {
        cin>>t1>>t2>>t3;
        if(e[t1][t2]>t3)// 保留长度最短的重边
        {
            e[t1][t2]=t3;
            e[t2][t1]=t3;
        }
    }
    //初始化dis数组
    for(int i=1; i<=n; i++)
        dis[i]=e[s][i];
    //初始化book数组
    for(int i=1; i<=n; i++)
        book[i]=0;
    book[s]=1;
    int u;
    for(int i=1; i<=n-1; i++) //计算源点到n-1个点的权
    {
        //找到离源点最近的点
        int minn=maxx;
        for(int j=1; j<=n; j++)
        {
            if(book[j]==0&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
        book[u]=1;//确定此点是离源点最近的点，然后从这点开始发散
        for(int v=1; v<=n; v++)
        {
            if(e[u][v]<maxx)//找到这个点可连接的其他点
            {
                if(dis[v]>dis[u]+e[u][v])//判断是否更新数据
                    dis[v]=dis[u]+e[u][v];
            }
        }
    }
    cout<<dis[t];
    return 0;
}

这道题用的是floyd算法，因为很明显题中要求出答案需要1到其他个点的距离以及其他各点的距离到1，我们直接将图填出来，然后再进行算术相加就行

#include<bits/stdc++.h>
using namespace std;
int mp[1005][1005];
int maxx=9999999;
int main()
{
    int n,m;
    cin>>n>>m;
    //对mp进行初始化
    for(int i=1;i<=n;i++)
    {
         for(int j=1;j<=n;j++)
                mp[i][j]=maxx;
    }
    for(int i=1;i<=m;i++)
    {
        int t1,t2,t3;
        cin>>t1>>t2>>t3;
        mp[t1][t2]=min(t3,mp[t1][t2]);//构造图
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(mp[i][j]>mp[i][k]+mp[k][j])
                    mp[i][j]=mp[i][k]+mp[k][j];//不断更新最短路径图
            }
        }
    }
    int sum=0;
    for(int i=2;i<=n;i++)
        sum=sum+mp[1][i]+mp[i][1];//求出来回时间的总和
    cout<<sum;
    return 0;
}

tuoluoo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最短路题解

图：顶点与边的集合。表示为G（V，E）。G表示图，V表示顶点个数(即图中的元素），E表示边的数；图中一定有顶点，边可以没有，任意两个顶点都可能有关系floyd算法：感觉像是一种动态规划，建立一个二维数组，用来表示两点间的最短路径值，开始的时候是初始化的值，用三个循环，不断判断通过其他顶点的参与，是否有最短路径可取，更新两点间的最短距离基本代码#include<bits/stdc++.h>.using namespace std;int main(){ int e[10
复制链接

扫一扫

专栏目录