迷宫问题

题目：在计算机中用图中的方块图表示迷宫，每个方块或为通道（白色），或为墙（黑色）。所求路径必须是简单路径，即求得的路径上不能重复出现同一通道块。

代码：

1.利用栈操作：

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

struct stack
{
	int i;
	int j;
	int path;
}Stack[100];

void findPaths(int maze[][10],int startx,int starty,int endx,int endy)
{
	int i=startx,j=starty,k;
	int top=0,path=-1;
	int find;
	Stack[top].i = i;
	Stack[top].j = j;
	Stack[top].path = path;
	maze[i][j] = -1;
	while (top>=0)
	{
		if (i==endx && j == endy)
		{
			printf("路径如下：\n");
			for (k=0;k<=top;k++)
			{
				printf("(%d,%d) ",Stack[k].i,Stack[k].j);
				if ((k+1)%3==0)
					printf("\n");
			}
			printf("\n");
			break;
		}
		find = 0;
		path = Stack[top].path;
		while (path<4 && find==0)
		{
			path++;
			switch(path)
			{
			case 0:
				i = Stack[top].i+1;
				j = Stack[top].j;
				break;
			case 1:
				i = Stack[top].i;
				j = Stack[top].j+1;
				break;
			case 2:
				i = Stack[top].i-1;
				j = Stack[top].j;
				break;
			case 3:
				i = Stack[top].i;
				j = Stack[top].j-1;
				break;
			}
			if (maze[i][j]==0)
				find = 1;
		}
		if (find)
		{
			Stack[top++].path = path;
			Stack[top].i = i;
			Stack[top].j = j;
			Stack[top].path = -1;
			maze[i][j] = -1;
		}
		else
		{
			maze[Stack[top].i][Stack[top].j] = 0;
			top--;
		}
	}
	if (top<0)
		printf("已没有路径可走！\n");	
}

int main(void)
{
	int maze[10][10] = {
		{1,1,1,1,1,1,1,1,1,1},  
		{1,0,0,1,1,0,0,1,0,1},  
		{1,0,0,1,0,0,0,1,0,1},  
		{1,0,0,0,0,1,1,0,0,1},  
		{1,0,1,1,1,0,0,0,0,1},  
		{1,0,0,0,1,0,0,0,0,1},  
		{1,0,1,0,0,0,1,0,0,1},  
		{1,0,1,1,1,0,1,1,0,1},  
		{1,1,0,0,0,0,0,0,0,1},  
		{1,1,1,1,1,1,1,1,1,1}};
	findPaths(maze,1,1,8,8);
	return 0;
}

2.利用递归操作：（黄队的）

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

#define N 10
#define INI 1
#define INJ 1
#define OUTI 8
#define OUTJ 8
int a[N][N] = {
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
        {1, 0, 0, 1, 0, 0, 0, 1, 0, 1},
        {1, 0, 0, 0, 0, 1, 1, 0, 0, 1},
        {1, 0, 1, 1, 1, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
        {1, 0, 1, 0, 0, 0, 1, 0, 0, 1},
        {1, 0, 1, 1, 1, 0, 1, 1, 0, 1},
        {1, 1, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

void print_labyrinth(int (*a)[N])
{
    int i, j;

    for (i = 0; i < N; i ++) {
        printf("\t");
        for (j = 0; j < N; j ++) {
            if (a[i][j] == 1)
                printf("■");
            else if (a[i][j] == -1)
                printf("⊙");
            else
                printf("□");
        }
        printf("\n");
    }
}

int flag = 0;
void backtrack_labyrinth(int i, int j)
{
    a[i][j] = -1;

    if ((i==OUTI) && (j==OUTJ))
        flag = 1;

    if ((flag!=1)&&(a[i+1][j]==0))
        backtrack_labyrinth(i+1, j);
    if ((flag!=1)&&(a[i-1][j]==0))
        backtrack_labyrinth(i-1, j);
    if ((flag!=1)&&(a[i][j+1]==0))
        backtrack_labyrinth(i, j+1);
    if ((flag!=1)&&(a[i][j-1]==0))
        backtrack_labyrinth(i, j-1);

    if (flag == 0)
        a[i][j] = 0;
}

int main(int argc, char **argv)
{
    printf("the labyrinth:\n");
    print_labyrinth(a);
    printf("one possible path:\n");
    backtrack_labyrinth(INI, INJ);
    print_labyrinth(a);
    return 0;
}