泛览天下

阅读,看尽天下事

数据结构与算法学习 (14)最短路径求解

2022-06-22 22:11:42


思路:初始化一个Final数组,全部设置为0,用于表示节点V0到某个顶点Vw,是否已经求得了最短路径的标记,如果已有则标记为1;声明一个D数组,表示节点V0 到某个顶点Vw 的路径;声明一个P数组,表示当前结点Vw 的前驱顶点的下标;


最短路径问题是图研究中的一个经典算法问题, 旨在寻找图(由结点和路径组成的)中两结点之间的最短路径。 算法具体的形式包括:

确定起点的最短路径问题 - 即已知起始结点,求最短路径的问题。

确定终点的最短路径问题 - 与确定起点的问题相反,该问题是已知终结结点,求最短路径的问题。在无向图中该问题与确定起点的问题完全等同,在有向图中该问题等同于把所有路径方向反转的确定起点的问题。

确定起点终点的最短路径问题 - 即已知起点和终点,求两结点之间的最短路径。

全局最短路径问题 - 求图中所有的最短路径。

Dijkstra(迪杰斯特拉)算法
Dijkstra算法是典型的最短路径路由算法,用于计算一个节点到其他所有节点的最短路径。主要特点是从起始点开始,采用贪心算法的策略,每次遍历到始点距离最近且未访问过的顶点的邻接节点,直到扩展到终点为止。

思路:

  1. 初始化一个 Final 数组,全部设置为0,用于表示节点V0
    到某个顶点Vw
    ,是否已经求得了最短路径的标记,如果已有则标记为1;
  2. 声明一个 D 数组,表示节点V0 到某个顶点Vw 的路径;
  3. 声明一个 P 数组,表示当前结点Vw 的前驱顶点的下标;
  4. 初始化 Final D , P 数组;
  5. 初始化 min 为无穷大,遍历 D 数组 找到对应最小权值 min 的顶点,记录对应下标k,标记 Final[k] = 1 ,表明找到最短路径;
  6. 之后通过Vk顶点向外扩散找到有关联边的顶点Vw更新 D 数组,若 !final[w] && min + G.arc[k][w] < D[w] ,则取 min + G.arc[k][w] 更新 D[w] ,更新 P[w] = k ;
  7. 遍历V1到 Vw ,重复上两条操作直到final数组全部为1,求得V0到其他顶点的最短路径。
    代码实现:
    /*
    G;网图
    v0: v0开始的顶点
    p[v]:前驱顶点下标
    D[v]:表示从v0到vw的最短路径长度和
   */
  void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D)
  {
  int v,w,k,min;
  k = 0;
  int final[MAXVEX];
  final[0] = 1;

  for(v = 0; v < G.numVertexes;v++){
      final[v] = 0;
      (*D)[v] = G.arc[0][v];
      (*P)[v] = 0;
  }
  (*D)[v0] = 0;
  final[v0] = 1;
  (*P)[v0] = -1;

  for (v = 1; v < G.numVertexes; v++)
  {
      min = INFINITYC;
      for (w = 0; w < G.numVertexes; w++)
      {
           if (final[w] != 1 && (*D)[w] < min)
           {
               //下标
               k = w;
               //最小权值 
               min = (*D)[w];
           }
      }
      final[k] = 1;
      for (w = 0; w < G.numVertexes; w++)
      {
          if (final[w] != 1 && min + G.arc[k][w] < ( *D)[w])
          {
              (*D)[w] =  min + G.arc[k][w];
              (*P)[w] =  k;
          }
      }
  }

}

Floyd算法

Floyd算法又称为插点法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法。通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
算法思路

从任意一条单边路径开始。所有两点之间的距离是边的权,如果两点之间没有边相连,则权为无穷大。
对于每一对顶点 u 和 v,看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。
1 把图用邻接矩阵D表示出来,定义一个矩阵P用来记录所插入点的信息;*
2 初始化P,P[v][w]表示从Vv到Vw需要经过的点, P[v][w]=w ;
3 对于每一对顶点 v 和 w,看看是否存在一个顶点 k 使得从 v 到 k 再到 w 比已知的路径更短。如果是更新 D[v,w] ,各个顶点插入图中,比较插点后的距离与原来的距离, D[v][w] = min( D[v][w], D[v][k]+D[k][w] ) ,如果 D[v][w] 的值变小,则 P[v][w]=k 。*
4 在D中包含有两点之间最短道路的信息,而在P中则包含了最短通路径的信息

代码实现:

void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D) {
    int v, w, k;
    for (v = 0; v < G.numVertexes; v++) {
        for (w = 0; w < G.numVertexes; w++) {
            (*D)[v][w] = G.arc[v][w];
            (*P)[v][w] = w;
        }
    }
    
    for (k = 0; k < G.numVertexes; k++) {
        for (v = 0; v < G.numVertexes; v++) {
            for (w = 0; w < G.numVertexes; w++) {
                if ((*D)[v][w] > (*D)[v][k] + (*D)[k][w]) {
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                    (*P)[v][w] = (*P)[v][k];
                }
            }
        }
    }
}