第十三周--数据结构-从一个顶点到其余各顶点的最短路径

本文详细介绍了使用迪杰斯特拉算法求解一个顶点到其余各顶点最短路径的问题,并给出了具体的C语言实现代码。通过一个具体示例,演示了如何从一个顶点出发找到图中其他顶点的最短路径。

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

/*
  *第十三周--数据结构-从一个顶点到其余各顶点的最短路径
  *Copyright (c) 2015 烟台大学计算机与控制工程学院
  *All right reserved.
  *writer:罗海员
  *date:2015年12月07日
  *问题描述:

*/

运行所用的示例:



代码实现如下:

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100

#define MAXV 100                //最大顶点个数
#define INF 32767       //INF表示∞
typedef int InfoType;

//以下定义邻接矩阵类型
typedef struct
{
    int no;                     //顶点编号
    InfoType info;              //顶点其他信息,在此存放带权图权值
} VertexType;                   //顶点类型

typedef struct                  //图的定义
{
    int edges[MAXV][MAXV];      //邻接矩阵
    int n,e;                    //顶点数,弧数
    VertexType vexs[MAXV];      //存放顶点信息
} MGraph;                       //图的邻接矩阵类型

//以下定义邻接表类型
typedef struct ANode            //弧的结点结构类型
{
    int adjvex;                 //该弧的终点位置
    struct ANode *nextarc;      //指向下一条弧的指针
    InfoType info;              //该弧的相关信息,这里用于存放权值
} ArcNode;

typedef int Vertex;

typedef struct Vnode            //邻接表头结点的类型
{
    Vertex data;                //顶点信息
    int count;                  //存放顶点入度,只在拓扑排序中用
    ArcNode *firstarc;          //指向第一条弧
} VNode;

typedef VNode AdjList[MAXV];    //AdjList是邻接表类型

typedef struct
{
    AdjList adjlist;            //邻接表
    int n,e;                    //图中顶点数n和边数e
} ALGraph;                      //图的邻接表类型

//功能:由一个反映图中顶点邻接关系的二维数组,构造出用邻接矩阵存储的图
//参数:Arr - 数组名,由于形式参数为二维数组时必须给出每行的元素个数,在此将参数Arr声明为一维数组名(指向int的指针)
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵
void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表
void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G
void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g
void DispMat(MGraph g);//输出邻接矩阵g
void DispAdj(ALGraph *G);//输出邻接表G


//功能:由一个反映图中顶点邻接关系的二维数组,构造出用邻接矩阵存储的图
//参数:Arr - 数组名,由于形式参数为二维数组时必须给出每行的元素个数,在此将参数Arr声明为一维数组名(指向int的指针)
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g)
{
    int i,j,count=0;  //count用于统计边数,即矩阵中非0元素个数
    g.n=n;
    for (i=0; i<g.n; i++)
        for (j=0; j<g.n; j++)
        {
            g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组,Arr[i*n+j]即是Arr[i][j],计算存储位置的功夫在此应用
            if(g.edges[i][j]!=0 && g.edges[i][j]!=INF)
                count++;
        }
    g.e=count;
}

void Ppath(int path[],int i,int v)  //前向递归查找路径上的顶点
{
    int k;
    k=path[i];
    if (k==v)  return;          //找到了起点则返回
    Ppath(path,k,v);            //找顶点k的前一个顶点
    printf("%d,",k);            //输出顶点k
}
void Dispath(int dist[],int path[],int s[],int n,int v)
{
    int i;
    for (i=0; i<n; i++)
        if (s[i]==1)
        {
            printf("  从%d到%d的最短路径长度为:%d\t路径为:",v,i,dist[i]);
            printf("%d,",v);    //输出路径上的起点
            Ppath(path,i,v);    //输出路径上的中间点
            printf("%d\n",i);   //输出路径上的终点
        }
        else  printf("从%d到%d不存在路径\n",v,i);
}
void Dijkstra(MGraph g,int v)
{
    int dist[MAXV],path[MAXV];
    int s[MAXV];
    int mindis,i,j,u;
    for (i=0; i<g.n; i++)
    {
        dist[i]=g.edges[v][i];      //距离初始化
        s[i]=0;                     //s[]置空
        if (g.edges[v][i]<INF)      //路径初始化
            path[i]=v;
        else
            path[i]=-1;
    }
    s[v]=1;
    path[v]=0;              //源点编号v放入s中
    for (i=0; i<g.n; i++)               //循环直到所有顶点的最短路径都求出
    {
        mindis=INF;                 //mindis置最小长度初值
        for (j=0; j<g.n; j++)       //选取不在s中且具有最小距离的顶点u
            if (s[j]==0 && dist[j]<mindis)
            {
                u=j;
                mindis=dist[j];
            }
        s[u]=1;                     //顶点u加入s中
        for (j=0; j<g.n; j++)       //修改不在s中的顶点的距离
            if (s[j]==0)
                if (g.edges[u][j]<INF && dist[u]+g.edges[u][j]<dist[j])
                {
                    dist[j]=dist[u]+g.edges[u][j];
                    path[j]=u;
                }
    }
    Dispath(dist,path,s,g.n,v);     //输出最短路径
}

int main()
{
    MGraph g;
    int A[7][7]=
    {
        {0,4,6,6,INF,INF,INF},
        {INF,0,1,INF,7,INF,INF},
        {INF,INF,0,INF,6,4,INF},
        {INF,INF,2,0,INF,5,INF},
        {INF,INF,INF,INF,0,INF,6},
        {INF,INF,INF,INF,1,0,8},
        {INF,INF,INF,INF,INF,INF,0}
    };
	printf("我看好你哦!\n");
    ArrayToMat(A[0], 7, g);
    Dijkstra(g,0);
    return 0;
}

运行结果:


### 蓝桥杯2025年第十六届省赛最短距离题目解析 目前尚未有官方发布的蓝桥杯2025年第十六届省赛的具体题目解析,因为该赛事可能还未举行或未公开相关内容。然而,基于以往蓝桥杯的比赛形式以及类似的最短路径问题[^3],可以推测此类题目通常涉及图论中的广度优先搜索(BFS)、Dijkstra算法或者Floyd-Warshall算法。 #### 基于假设的题目描述 假定蓝桥杯2025年第十六届省赛有一道关于最短距离的题目如下: > 输入三个正整数 `w` (1<w<21), `m` (1<m<10001), `n` (1<n<10001),其中 `m != n`。这三个正整数表示一个建筑物内的楼层编号范围 `[m, n]` 及其宽度参数 `w`。每层楼之间的连接关系由某种特定规则定义(例如电梯、楼梯)。求从第 `m` 层到第 `n` 层的最短路线经过几层楼。 此类型的题目可以通过构建图模型来解决,并利用 BFS 来寻找最短路径--- #### 解决思路与代码实现 ##### 思路分析 为了找到从起 `m` 到终 `n` 的最短路径,可采用以下方法: - **建模**:将每一层视为图的一个,两层之间如果有直接可达的关系,则建立一条边。 - **算法选择**:由于本题仅需计算单源最短路径且权重均为单位权值,因此适合使用广度优先搜索(BFS)。 以下是 Python 实现代码示例: ```python from collections import deque def shortest_path(w, m, n): # 初始化队列并记录访问状态 queue = deque([(m, 0)]) # 当前层数及其步数 visited = set([m]) # 已经访问过的层数 while queue: current_floor, steps = queue.popleft() # 如果到达目标楼层则返回步数 if current_floor == n: return steps # 计算下一层可达的楼层 next_floors = [ current_floor + w, current_floor - w, current_floor * 2 # 假设存在特殊操作如乘法跳转 ] for floor in next_floors: if floor not in visited and 1 < floor < 10001: # 确保在合法范围内 visited.add(floor) queue.append((floor, steps + 1)) return -1 # 若无法达到目标楼层 # 测试样例 print(shortest_path(3, 2, 8)) # 输出应为具体步数值 ``` 上述代码通过 BFS 方法逐步扩展当前所在楼层的所有可能性,直到找到目标楼层为止。时间复杂度主要取决于图的规模,即 O(V+E),其中 V 是顶点数量,E 是边的数量。 --- #### 注意事项 1. 题目中可能会加入额外约束条件,比如某些楼层不可达或具有不同的跳跃规则。 2. 对于更大的数据范围,需要优化存储结构以减少内存消耗。 3. 如果涉及到加权图,则需要改用 Dijkstra 或其他适用算法。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值