高级迷宫算法设计

题目

给定一个m*n大小的矩阵T，对于其中的每个位置（i，j），有T[i,j] >=—1：如果T[i,j] =—1则表示该位置为墙；如果T[i,j] >=0为则表示该位置为空，但该位置的权值为T[i,j]。 坐标(1,1)为起点S，坐标(m,n)的位置为终点T（默认这两个位置的元素为0）。请设计一个程序，若该迷宫存在一条路径连接S和T（即该路径所经过的位置的权值皆>=0）：则返回连接S和T的一条“最短”路径；否则返回“无”。注意一条连接S和T的路径的“长度”定义为它所走过的位置的权值之和。连接S和T的“最短”路径是指在所有连接S和T的路径当中，长度最小的那一条。

注意在走该迷宫时，每次只能选择“上下左右”四个方向中的一个进行移动。如果将要移动的位置有墙，则待在原地。

基本思路：

可先基于迷宫构造相应的无向图，再利用Dijkstra算法的思路进行求解。注意这个问题不能直接利用Dijkstra算法进行求解。

代码：

#include<stdio.h>
#include<stdlib.h>

#define M 4
#define N 4
#define MAX 250
int path1[MAX];//储存最后输出路线
int p1 = -1;
int x, y;//输出时候记录坐标
typedef struct Node
{
	int data;
	int tf;
	int length;
	int before;//存放上一个结点
}IJJ;
IJJ path[M * N];//邻接矩阵
int maze[M + 2][N + 2] =
{
	{-1,-1,-1,-1,-1,-1},
	{-1, 0, 1, 2, 1,-1},
	{-1,-1, 1, 3, 5,-1},
	{-1,-1, 100, 2,-1,-1},
	{-1,-1, 0, 1, 0,-1},
	{-1,-1,-1,-1,-1,-1}
};
int mg[M * N][M * N];

void locat(int i)
{
	int w = 1; int e = 1;
	int yu;
	for(int w=1;w<=M;w++)
		for (int e=1;e<=N; e++)
		{
			yu = (w - 1) * N + e - 1;
			if (yu==i)
			{
				x = w; y = e;
				return;
			}
	}
}
void transform()//将迷宫转换成图的邻接矩阵,此步成功
{for(int i=0;i<M*N;i++)
	for (int j = 0; j < M * N; j++)
	{
		mg[i][j] =MAX;
	}
	for(int i=1;i<=M;i++)
		for (int j = 1; j <= N; j++)
		{
			if (maze[i][j + 1] != -1)//右边结点
				mg[(i - 1) * N + j-1][(i - 1) * N + j + 1-1] = maze[i][j + 1];

			else if(maze[i][j + 1] == -1&&j!=N) mg[(i - 1) * N + j-1][(i - 1) * N + j + 1-1] = MAX;

			if (maze[i][j -1] != -1)//左边节点
				mg[(i - 1) * N + j-1][(i - 1) * N + j -1-1] = maze[i][j - 1];
			//
			else if (maze[i][j - 1] == -1 && j != 1) mg[(i - 1) * N + j-1][(i - 1) * N + j - 1-1] = MAX;

			if (maze[i-1][j] != -1)//上边节点
				mg[(i - 1) * N + j-1][(i - 2) * N + j-1] = maze[i-1][j ];

			else if (maze[i-1][j ] == -1 && i != 1) mg[(i - 1) * N + j-1][(i - 2) * N + j-1 ] = MAX;

			if (maze[i +1][j] != -1)//下边节点
				mg[(i - 1) * N + j-1][(i ) * N + j-1] = maze[i + 1][j];

			else if (maze[i + 1][j] == -1 && i != M) mg[(i - 1) * N + j-1][(i ) * N + j-1] = MAX;

		}
}
int min()//找路程最小项
{
	int i = 0;
	while (path[i].tf == 1)
	{
		i++;
	}//确保i没有遍历过
	//printf("i是%d\n", i);
	if (i == M * N - 1)
		return -1;
	int mini =i;
	for (int i = 0; i < M * N-1; i++)
	{
		if ((path[i].length < path[mini].length) && (path[i].tf == 0))
			mini = i;
	}
	//printf("%d %d %d\n", path[mini].tf, mini,path[mini].length);
	return mini;
}
void ShortestPath_Dijkstra()
{
	for (int i = 0; i < M * N; i++)//初始化
	{
		path[i].data = i;
		path[i].length = MAX;
		path[i].tf = 0;
		path[i].before = -1;//代表没有前屈
	}
	int p;
	//goto的位置
	//找到距离最短的结点，然后改变这个节点联通的结点的距离
	//再次找距离最小的结点，重复操作
	//这个结点不能是终点
	//除了终点之外所有的点都被操作过之后，输出最小路径
	path[0].length = 0;
	int temp;
	int y =M*N-1;

	while (y--)
	{p = min();//hi陷入死循环，出不来
	//printf("%d\n", p);
		path[p].tf = 1;
		for (int i = 0; i < M * N; i++)
		{
			if (mg[p][i] < MAX)
			{
				temp = mg[p][i] + path[p].length;
				if (temp < path[i].length)
				{
					path[i].length = temp;
					path[i].before = p;
				}
			}
		}

	}
}

void output()
{
	int sb = M * N - 1;
	path1[++p1] = sb;
	while (sb != 0)
	{
		sb = path[sb].before;
		path1[++p1] =sb;
	}
	printf("路径为：");
	for (int i = p1; i > 0; i--)
	{
		locat(path1[i]);
		//printf("*");
		printf("(%d,%d)->", x, y);
	}
	printf("(%d,%d)", M, N);
}

int main()
{
	transform();
	ShortestPath_Dijkstra();
	output();
}

运行结果如下：