POJ 3984 迷宫问题 (Dijkstra)

迷宫问题

Description
定义一个二维数组：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到

右下角的最短路线。

Input
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output
左上角到右下角的最短路径，格式如样例所示。

Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

解决方案：

对于这题，我们可以把它maze数组转化为一个图，不能通过的话，即两点之间无路径，然后利用Dijkstra算法寻找S点到T点的最短路径。

POJ 3984

#include <stdio.h>
#include <string.h>

#define N 5

void print(int value, int prev[N*N])
{
if (value >= 0)
{
int x = value/N;
int y = value%N;
print(prev[value], prev);
printf("(%d, %d)\n", x, y);
}
}

void solve(int maze

)
{
int visited

;//是否被访问了
memset(visited, 0, sizeof(visited));//初始化为0

int offset[N-1][2] = {
{1, 0},//向上
{-1, 0},//向下
{0, -1},//向左
{0, 1}//向右
};

int queue[N*N];//队列
int front = 0;//头指针
int rear = 0;//尾指针

int x = 0;//起点x坐标
int y = 0;//起点y坐标
queue[++rear] = 0;//向队列添加第一个点，即起始点
visited[x][y] = 1;//0结点被访问过

int prev[N*N];//保留每个点的前结点
memset(prev, -1, sizeof(prev));//初始化为-1
prev[0] = -1;//0的前结点为-1

while (front <= rear)
{
int i;
int newx;
int newy;
front++;//相当于弹出了一个结点
x = queue[front]/N;
y = queue[front]%N;

for (i = 0; i < N - 1; i++)
{
newx = x + offset[i][0];//偏移之后的x坐标
newy = y + offset[i][1];//偏移之后的y坐标
if (newx >= 0 && newx < N && newy >= 0 && newy < N && !visited[newx][newy] && !maze[newx][newy])
{
rear = (rear + 1)%(N*N);
queue[rear] = newx*N + newy;
prev[newx*N + newy] = x*N + y;
visited[newx][newy] = 1;
}
}
}
print(N*N - 1, prev);
}

int main()
{
int maze

;
int i = 0;
int j = 0;
while (scanf("%d", &maze[i][j++]) != EOF)
{
if (j == 5)
{
i++;
j = 0;
}
if (i == 5)
{
solve(maze);
i = 0;
}
}
return 0;
}