7-2 公路村村通 迪杰斯特拉(dijkstra)算法

最新推荐文章于 2023-11-15 20:11:51 发布
最新推荐文章于 2023-11-15 20:11:51 发布
阅读量321 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 算法 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61351908/article/details/122515400
版权

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

同笔者其他文章一样，

在完成这道题之前， 首先要对构迪杰斯特拉算法的框架有一定的理解。

之后再根据题目的要求进行恰当的修改。

框架代码： 

#include <iostream>
#include <stdlib.h>
#include <queue>
using namespace std;

#define INFINITY 32767

typedef struct
{
    int *vexs;   //顶点表
    int **arc;  //邻接矩阵，可看作边表
    int numVertexes,numEdges;  //图中当前的顶点数和边数
}MGraph;

MGraph* InitGraph(int numVer,int numEdge)
{
    MGraph *G;
    G = (MGraph*)malloc(sizeof(MGraph));
    G->vexs = (int*)malloc(sizeof(int)*numVer);
    G->arc = (int**)malloc(sizeof(int*)*numVer);

    for(int i=0;i<numVer;i++)
    {
    	G->vexs[i]=i;
        G->arc[i] = (int*)malloc(sizeof(int)*numVer);
        for(int j=0;j<numVer;j++)
        {
            if(i==j)
                G->arc[i][j] = 0;
            else G->arc[i][j] = INFINITY;
        }
    }
    G->numVertexes = numVer;
    G->numEdges = numEdge;

    return G;
}

int GetMin(MGraph *G,int *s,int *d)
{
    int min=INFINITY;
    int index;
    for(int i=0;i<G->numVertexes;i++)
    {
        if(s[i]==0 && d[i]<min)
        {
            min = d[i];
            index = i;
        }
    }

    return index;
}

void Dijkstra(MGraph *G,int index)
{
    int *s = (int*)malloc(sizeof(int)*G->numVertexes);
    int *p = (int*)malloc(sizeof(int)*G->numVertexes);
    int *d = (int*)malloc(sizeof(int)*G->numVertexes);


    for(int i=0;i<G->numVertexes;i++)  //初始化辅助数组
    {
        if(G->arc[index][i]>0 && G->arc[index][i]!=INFINITY)
        {
            p[i] = index;
            d[i] = G->arc[index][i];
        }    
        else 
        {
            p[i] = -1;
            d[i] = INFINITY;
        }

        if(i==index)
        {
            s[i]=1;
            d[i]=0;
        }
        else
            s[i]=0;
    }

    for(int i=0;i<G->numVertexes;i++)
    {
        int index = GetMin(G,s,d);
        s[index] = 1;
        for(int j=0;j<G->numVertexes;j++)
        {
            if(s[j]==0 && d[index] + G->arc[index][j] < d[j])
            {
                d[j] = d[index] + G->arc[index][j];
                p[j] = index;
            }
        }
    }

}

int main()
{
    MGraph *G;
    int N,M;
    cin>>N>>M;


    G = InitGraph(N,M);
    
    for(int i=0;i<M;i++)
    {
        int x,y,weight;
        cin>>x>>y>>weight;
        G->arc[x-1][y-1] = weight;
    }

    Dijkstra(G,0);

    return 0;
}

Dijsktra()函数中3个辅助数组：

  • S数组:记录了目标顶点到其他顶点的最短路径是否求得（1表示已求得，0表示为求得）
  • P数组:记录了目标顶点到其他顶点的最短路径的前驱节点（-1表示无前驱，否则为编号）
  • D数组:记录了目标顶点到其他顶点的最短路径的长度

 附上本题完整代码：

#include <iostream>
#include <stdlib.h>
#include <queue>
using namespace std;

#define INFINITY 32767

typedef struct
{
    int *vexs;   //顶点表
    int **arc;  //邻接矩阵，可看作边表
    int numVertexes,numEdges;  //图中当前的顶点数和边数
}MGraph;

MGraph* InitGraph(int numVer,int numEdge)
{
    MGraph *G;
    G = (MGraph*)malloc(sizeof(MGraph));
    G->vexs = (int*)malloc(sizeof(int)*numVer);
    G->arc = (int**)malloc(sizeof(int*)*numVer);

    for(int i=0;i<numVer;i++)
    {
    	G->vexs[i]=i;
        G->arc[i] = (int*)malloc(sizeof(int)*numVer);
        for(int j=0;j<numVer;j++)
        {
            if(i==j)
                G->arc[i][j] = 0;
            else G->arc[i][j] = INFINITY;
        }
    }
    G->numVertexes = numVer;
    G->numEdges = numEdge;

    return G;
}

int GetMin(MGraph *G,int *s,int *d)
{
    int min=INFINITY;
    int index;
    for(int i=0;i<G->numVertexes;i++)
    {
        if(s[i]==0 && d[i]<min)
        {
            min = d[i];
            index = i;
        }
    }

    return index;
}

int* Dijkstra(MGraph *G,int index,int end)
{
    int *s = (int*)malloc(sizeof(int)*G->numVertexes);
    int *p = (int*)malloc(sizeof(int)*G->numVertexes);
    int *d = (int*)malloc(sizeof(int)*G->numVertexes);


    for(int i=0;i<G->numVertexes;i++)  //初始化辅助数组
    {
        if(G->arc[index][i]>0 && G->arc[index][i]!=INFINITY)
        {
            p[i] = index;
            d[i] = G->arc[index][i];
        }    
        else 
        {
            p[i] = -1;
            d[i] = INFINITY;
        }

        if(i==index)
        {
            s[i]=1;
            d[i]=0;
        }
        else
            s[i]=0;
    }

    for(int i=0;i<G->numVertexes;i++)
    {
        int index = GetMin(G,s,d);
        s[index] = 1;
        for(int j=0;j<G->numVertexes;j++)
        {
            if(s[j]==0 && d[index] + G->arc[index][j] < d[j])
            {
                d[j] = d[index] + G->arc[index][j];
                p[j] = index;
            }
        }
    }

    int *road;
    road  = (int*)malloc(sizeof(int)*30);
    int i=end,cnt=2;
    while(i!=-1)  //用p数组找路径
    {
        road[cnt]=i;
        i=p[i];
        cnt++;
    }

    road[1]=d[end];  //数组road[1]存最短路径
    road[0]=cnt-1;   //数组road[0]存总的路径数
    //这样便于在主函数中对边time和length的路径是否相同
    //也就是真正的路径是从2开始，从cnt倒叙开始，cnt个数

    return road;


 
}

int main()
{
    MGraph *G_length;
    MGraph *G_time;
    int N,M;
    cin>>N>>M;


    G_length = InitGraph(N,M);
    G_time = InitGraph(N,M);
    
    for(int i=0;i<M;i++)
    {
        int x,y,way,length,time;
        cin>>x>>y>>way>>length>>time;
        if(way==1)
        {
            G_length->arc[x][y] = length;
            G_time->arc[x][y] = time;
        }else{
            G_length->arc[x][y] = length;
            G_length->arc[y][x] = length;
            G_time->arc[x][y] = time;
            G_time->arc[y][x] = time;
        }
    }

    int start,end;
    cin>>start>>end;


    int *road_length,*road_time;
    //cout<<endl<<"Time = ";
    road_time = Dijkstra(G_time,start,end);
    
    //cout<<endl<<"Distance = ";
    road_length = Dijkstra(G_length,start,end);

    //总之运行完算法，返回，想办法满足题目要求的输出即可。

    int flag = 0; //0表示两条路线不一样，1表示两条路线一样
    if(road_length[0] == road_time[0])
    {
        int j;
        for(j=2;j<road_length[0]+2;j++)
        {
            if(road_length[j]!=road_time[j])
                break;
        }

        if(j==road_length[0]+2)
            flag=1;
    }

    if(flag==1)
    {
        printf("Time = %d; Distance = %d:",road_time[1],road_length[1]);
        for(int j=road_time[0];j>=2;j--)
        {
        if(j!=2)
            printf(" %d =>",road_time[j]);
        else printf(" %d",road_time[j]);
        }
    }else{
        cout<<endl<<"Time = "<<road_time[1]<<":";
        for(int j=road_time[0];j>=2;j--)
        {
        if(j!=2)
            printf(" %d =>",road_time[j]);
        else printf(" %d",road_time[j]);
        }
        cout<<endl<<"Distance = "<<road_length[1]<<":";
        for(int j=road_length[0];j>=2;j--)
        {
        if(j!=2)
            printf(" %d =>",road_length[j]);
        else printf(" %d",road_length[j]);
        }
    }
  


    return 0;
}

总结：

        主要学习迪杰斯特拉算法的写法。针对于本题，就是对迪杰斯特拉算法的应用。为满足题目要求，本代码虽能够实现，但是逻辑较差，阅读代码稍微较困难。

亮子i_12138
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
PTA-公路村村通
dsp1234566的博客
06-21 452
现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。 输入样例: 6 15 1 2 5 1 3 3 1 4 7 1 5 4
MATLAB轻松绘制地图路线-Dijkstra(迪杰斯特拉)算法最短路径规划
05-06
博客：MATLAB轻松绘制地图路线——Dijkstra(迪杰斯特拉)算法最短路径规划 所用工程文件
公路村村通
勤劳的码农
03-05 1404
7-10公路村村通（30 分） 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编...
PTA 7-2 公路村村通
最新发布
Simon_Tilly的博客
11-15 172
现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。
《数据结构》08-图7 公路村村通
叫我皮卡丘
11-18 1843
题目 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不...
最小生成树Kruskal
左岸的博客
10-11 233
//kruscal 算法 #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; int per[105],n; struct node//结构体来保存边 { int a,b; int dis; }x[5005]; bool cmp(node a,node b) { retu
浙大PTA 08-图7 公路村村通（C语言详解，Prim算法应用）
m0_65435471的博客
07-31 838
现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。
C++实现Dijkstra(迪杰斯特拉)算法
08-19
主要为大家详细介绍了C++实现Dijkstra(迪杰斯特拉)算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++华沙Warshall与迪杰斯特拉Dijkstra算法实现.zip
08-20
C++实现Warshall算法与Dijkstra算法
迪杰斯特拉算法（Dijkstra算法） c++实现.zip
10-09
迪杰斯特拉算法c 迪杰斯特拉算法（Dijkstra算法） c++实现.zip
PTA 数据结构 公路村村通
weixin_42606045的博客
11-12 554
7-11 公路村村通 （30 分） 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: ...
pta 公路村村通
k的博客
05-30 1835
现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保...
08-图7 公路村村通
bxg1065283526的博客
03-06 873
思路：该题为最小生成树，利用Prime算法每次找到离最小生成树最近的没有被访问过的点加入最小生成树，直至所有点都加入了最小生成树。cost数组记录了点到最小生成树的距离，最开始是其他点到起点的距离，每次选择一个加入一个点后，检查没有加入的点的到新加入的点距离是否比之前到最小生成树的距离短，若小则更新。#include&lt;iostream&gt; using namespace std; #de...
浙大陈越数据结构-08-图7 公路村村通
chanforg1的博客
05-17 224
在最小堆中选择最小的边，判断终点是否在图中，不在的话就将终点收进来并将终点的所有与外界相连的边收进来。如果收进来的点个数小于所有点的个数，说明图不是连通的，返回-1.不需要存储最小生成树的图，只需要统计出所用的花费即可。一直到收进来的点等于所有点个个数或者最小堆已空。根据题意是稠密图，使用邻接矩阵区域存储整个图。从一个点开始，将它的所有边放到最小堆中。从一个点开始向外扩展使用prim算法。使用最小堆去选择下一条边 【优先队列】
PTA-08-图7 公路村村通
Sukihasimoto的博客
12-01 226
题目描述 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数...
最短路径算法-迪杰斯特拉(Dijkstra)算法
07-27
迪杰斯特拉算法是一种用于求解带权有向图中单源最短路径的算法。它以一个起始节点为基准，逐步扩展到其他节点，通过不断更新节点的最短路径来找到起始节点到其他节点的最短路径。 算法的基本思想是从起始节点开始，先将起始节点到所有其他节点的距离初始化为无穷大，然后逐步更新距离，直到找到最短路径。具体步骤如下： 1. 初始化距离数组dist[]，表示起始节点到各个节点的最短距离。将起始节点的距离初始化为0，其他节点的距离初始化为无穷大。 2. 创建一个集合visited[]，用于记录已经求得最短路径的节点。 3. 重复以下步骤，直到所有节点都被访问过： a. 从未访问过的节点中选择一个距离起始节点最近的节点，将其标记为visited[]。 b. 更新与该节点相邻的节点的最短距离。如果经过当前节点到达相邻节点的路径比原先的最短距离更短，则更新最短距离。 4. 最终，dist[]数组中存储的就是起始节点到各个节点的最短路径长度。 迪杰斯特拉算法的时间复杂度为O(V^2)，其中V为节点数。该算法适用于边的权重非负的情况。如果希望在存在负权边的图中求解最短路径，则需要使用其他算法，如贝尔曼-福特算法或弗洛伊德算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

亮子i_12138

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值