代码分析——最短路径Dijkstra/Floyed(附对比Prim)

村庄供水站选址的最短路径算法分析

Meriellan

已于 2024-11-05 17:24:02 修改

阅读量684

点赞数 21

CC 4.0 BY-SA版权

分类专栏：上机百题文章标签：算法 c语言

于 2024-11-05 11:39:41 首次发布

本文链接：https://blog.csdn.net/m0_62825044/article/details/143500520

上机百题专栏收录该内容

6 篇文章

订阅专栏

（2021）n个村庄各自相通，要在某一处村庄里修供水站，确定最优位置使供水站到所有村庄的路程之和最少

审题：
本题明显考察的最短路径问题，常用有dijkstra和floyed算法，用哪种?
答：根据题意供水站可以在任意一个村庄中，属于任意两点最短路径，应选用floyed算法。

dijkstra算法
以起点为中心，寻找到各点（各点可以看做是独立的）的最短路径。 dijkstra的思想：

借用三个辅助向量组，一次又一次更新各顶点的第n条最短路径
- flag[i]：=1表示已找到最短路径
  dist[i]：从起点到V_i的最短路径长度
  path[i]：从起点到V_i的最短路径
- 设总结点数为n，从起点到各顶点的第一条最短路径dist[u]，u为最短路径的终点
  dist[u]=min{dist[w]&&flag[w]=0} , w=1,2……n-1
- 找到目前最短路径后更新path[u]，path最好包含两个东西
  + pi[i] ：path[u].pi[end]即最短路径的终点
  + end : 这个路径经过的点数-1

/*必要的初始化 */

for(i=0;i<n;i++)
{
	flag[i]=0;
	dist[i]=G.A[v0][i];//vo到i的权值
	path[i].pi[0]=v0
	path[i].end=0;
}

/*第一条最短路径*/

	m=MAX;//MAX表示目前机器表示的最大值，即无路径长度为∞
	for(w=0;w<=n-1;w++)
	{
		if(dist[w]<m&&falg[w]==0)
		{
			u=w;//u为最短路径的终点
			m=dist[w];
		}
	}
	if(m==MAX)break;//跳出while循环
	flag[u]=1;

	path[u].end++;//现在是从起点到u,
	//第一条最短路径：path[u].pi[0]=起点，path[u].pi[1]=u
	path[u].pi[end]=u;

查找最短路径：
已知现在path[u]是最短路径
以v_w为终点，试图从起点——>V_u——>V_w
若dist[w] > dist[u]+<V_u,V_w>之间的权值，则从起点——>V_u——>V_w更近
令dist[w] = dist[u]+<V_u,V_w>之间的权值
- 找到当前的最短路径后更新path[w]

/*试图插入中间结点并寻找最短路径*/

for(w=0;w<=n-1;w++)
{
	if(flag[w]==0&&dist[w]>dist[u]+G.A[u][w])
	{
		dist[w]=dist[u]+G.A[u][w];
		path[w]=path[u];
	}
}

/*完整算法描述*/
**********************************************************
/*path结构体的定义*/
typedef struct
{
	int pi[n];
	int end;
}pathtype;;

pathtype path[n];
int dist[n];

//此处图以邻接矩阵G.A[i][j]形式给出
void Dijkstra(mgraph G,int dist[],pathtype path[],int v0,int n)
{
	int i,count,flag[n],m,u,w;//count为计数器，m表示最初的权值，没赋值之前都是MAX，即∞
	//初始化
	for(i=0;i<n;i++)
	{
	flag[i]=0;
	dist[i]=G.A[v0][i];//vo到i的权值
	path[i].pi[0]=v0
	path[i].end=0;
	}
	flag[v0]=1;
	count=1;
	
	/*因为除了v0外共有n-1个点，
	所以寻找最短路径的两个过程应放在while(count<=n-1)中*/
	while(count<=n-1)
	{
		m=MAX;//MAX表示目前机器表示的最大值，即无路径长度为∞
		for(w=0;w<=n-1;w++)
		{
			if(dist[w]<m&&falg[w]==0)
			{
				u=w;//u为最短路径的终点
				m=dist[w];
			}
		}
		if(m==MAX)break;//跳出while循环
		flag[u]=1;
	
		path[u].end++;//现在是从起点到u,
		//第一条最短路径：path[u].pi[0]=起点，path[u].pi[1]=u
		path[u].pi[end]=u;

		for(w=0;w<=n-1;w++)
		{
			if(flag[w]==0&&dist[w]>dist[u]+G.A[u][w])
			{
				dist[w]=dist[u]+G.A[u][w];
				path[w]=path[u];
			}
		}

		count++;
	}
}

对比：prim算法
- prim算法常用来找最小生成树。最小生成树是一个图的边的权值之和最小的生成树
- prim的思想：从一个点开始，以自己为中心寻找离它最近的一个点，从而扩大"身体"（现在身体里有两个点），以"身体"为中心找最近的点，继续扩大身体……所以最小生成树一般不规则，可能不唯一
floyed算法

各点均可作为起点，找任意两顶点间最短路径

实质用n次djisktra算法也可以，但floyed更简便
用矩阵来存储距离，任意两顶点间距离D[i][j]

/*必要的初始化距离矩阵*/
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (graph[i][j] == 0 && i != j) {
                dist[i][j] = MAX; // 如果没有直接路径且不是同一个顶点，则设置为MAX
            } else {
                dist[i][j] = graph[i][j]; // 否则设置为实际的边权重
            }
        }
    }

尝试从V_i——>V_k——>V_j
注意：此处的“试探”，k可以是0-n，表示经历第k个结点
当 k = 0 时，只考虑直接相连的顶点对。
当 k = 1 时，考虑经过第一个顶点的所有路径，第一个顶点可以是图中任意点。
当 k = 2 时，考虑经过第二个顶点的所有路径，第二个顶点可以是图中任意点。
……

/*更新距离矩阵*/

for (int k = 0; k < V; k++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                if (dist[i][k] != MAX && dist[k][j] != MAX && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }

还有一个问题，当结点未知为ｎ时，注意动态分配空间

/*分配空间*/
//**dist指指向二维数组（矩阵）的指针
int **dist = (int **)malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        dist[i] = (int *)malloc(n * sizeof(int));
    }

/*完整代码*/
**************************************************
#include <stdio.h>
#include <limits.h> // 包含INT_MAX的定义
#include <stdlib.h> // 包含malloc和free的定义

#define MAX INT_MAX // 定义一个足够大的数作为无穷大

// 打印最终的距离矩阵
void printSolution(int **dist, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (dist[i][j] == MAX) {
                printf("%7s", "INF");
            } else {
                printf("%7d", dist[i][j]);
            }
        }
        printf("\n");
    }
}

// Floyd算法计算所有顶点对之间的最短路径
void floyd(int **graph, int n) {
    int **dist = (int **)malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        dist[i] = (int *)malloc(n * sizeof(int));
    }

    // 初始化距离矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (graph[i][j] == 0 && i != j) {
                dist[i][j] = MAX; // 如果没有直接路径且不是同一个顶点，则设置为MAX
            } else {
                dist[i][j] = graph[i][j]; // 否则设置为实际的边权重
            }
        }
    }

    // 更新距离矩阵
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dist[i][k] != MAX && dist[k][j] != MAX && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    // 打印最终的距离矩阵
    printSolution(dist, n);

    // 释放动态分配的内存
    for (int i = 0; i < n; i++) {
        free(dist[i]);
    }
    free(dist);
}

int main() {
    int n; // 顶点数量
    printf("请输入顶点数量: ");
    scanf("%d", &n);

    // 动态分配邻接矩阵的内存
    int **graph = (int **)malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        graph[i] = (int *)malloc(n * sizeof(int));
    }

    // 输入图的邻接矩阵（无向图）
    printf("请输入邻接矩阵:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }

    // 调用Floyd算法计算所有顶点对之间的最短路径
    floyd(graph, n);

    // 释放动态分配的内存
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);

    return 0;
}