迷宫问题

广度优先搜索

#include "stdio.h" 

#define COL 10
#define ROW 10

#define BOOL int
#define TRUE 1
#define FALSE 0

typedef struct plot
{
        int col;
        int row;
}Plot;

int Maze[COL][ROW] = {    {1,1,1,1,1,1,1,1,1,1},
                                        {0,0,0,0,0,0,1,0,0,1},
                                        {1,1,0,1,1,0,1,0,1,1},
                                        {1,1,0,1,0,0,0,0,0,1},
                                        {1,0,0,1,1,0,1,1,0,1},
                                        {1,0,1,0,0,0,1,1,1,1},
                                        {1,0,1,0,1,1,0,0,0,1},
                                        {1,0,1,0,1,1,0,1,0,1},
                                        {1,0,1,0,0,0,0,1,0,0},
                                        {1,1,1,1,1,1,1,1,1,1}};

int head = 0, rear = 0;
int level = 2;
Plot flag_queue[COL * ROW];

void get_path(int x, int y);
void width_flag(int x, int y);
void en_queue(int x, int y);
void out_queue();
BOOL queue_not_empty();
void print_path();
void print_maze();

int main()
{
        width_flag(8, 9);
        get_path(1, 0);
        print_path();
        print_maze();
        return 0;
}

void get_path(int x, int y)
{
        int i = 0;
        level = Maze[x][y];

        while(level>1)
        {
                flag_queue[i].col = x;
                flag_queue[i].row = y;
                i++;
                level--;
                if(x>0 && Maze[x-1][y]==level)
                        x--;
                else if(y+1
                        y++;
                else if(x+1
                        x++;
                else
                        y--;
        }
        level = i;
}

void width_flag(int x, int y)
{
        en_queue(x, y);
        while(queue_not_empty())
        {
                x = flag_queue[head].col;
                y = flag_queue[head].row;
                level = Maze[x][y] + 1;

                if(x>0 && Maze[x-1][y]==0)
                        en_queue(x-1, y);
                if(y+1
                        en_queue(x, y+1);
                if(x+1
                        en_queue(x+1, y);
                if(y>0 && Maze[x][y-1]==0)
                        en_queue(x, y-1);

                out_queue();
        }
}

void en_queue(int x, int y)
{
        Maze[x][y] = level;
        flag_queue[rear % (COL * ROW)].col = x;
        flag_queue[rear % (COL * ROW)].row = y;
        rear = (rear + 1) % (COL * ROW);
}

void out_queue()
{
        head = (head + 1) % (COL * ROW);
}

BOOL queue_not_empty()
{
        if(head==rear) 
                return FALSE;
        else
                return TRUE;
}

void print_path()
{
        int i;
        printf("\nStart->");
        for(i=0; i
                printf("(%d,%d)->", flag_queue[i].col, flag_queue[i].row);
        printf("end\n\n");
}

void print_maze()
{
        int i,j;
        for(i=0; i
        {
                for(j=0; j
                        printf("=",Maze[i][j]);
                printf("\n");
        }
}

深度搜索

#include "stdio.h"

#define ROW 8
#define COL 8

int Maze[COL][ROW] = {    {1,1,1,1,1,1,1,1},
                        {0,0,0,0,0,0,0,1},
                        {1,0,1,0,1,1,0,1},
                        {1,0,1,1,1,0,0,1},
                        {1,1,1,0,0,0,1,1},
                        {1,0,0,0,1,1,1,1},
                        {1,0,1,0,0,0,0,0},
                        {1,1,1,1,1,1,1,1}};

typedef struct plot
{
        int col;
        int row;
}Plot;

int top = 0;
Plot path_stack[COL * ROW];

void depth_search(int i, int j);
void push(int i, int j);
void pop();
void print_path();

int main()
{
        depth_search(1, 0);
        print_path();
        return 0;
}

void depth_search(int i, int j)
{
        Maze[i][j] = 2;
        push(i, j);
        while(1)
        {
                if(j+1
                {
                        j++;
                        Maze[i][j] = 2;
                        push(i, j);
                        continue;
                }
                if(i+1
                {
                        i++;
                        Maze[i][j] = 2;
                        push(i, j);
                        continue;
                }
                if(j>0 && Maze[i][j-1]==0)
                {
                        j--;
                        Maze[i][j] = 2;
                        push(i, j);
                        continue;
                }
                if(i>0 && Maze[i-1][j]==0)
                {
                        i--;
                        Maze[i][j] = 2;
                        push(i, j);
                        continue;
                }
                if(i!=6 || j!=7)
                        pop();
                else
                        break;
        }
}

void push(int x, int y)
{
        path_stack[top].col = x;
        path_stack[top].row = y;
        top++;
}

void pop()
{
        top--;
}

void print_path()
{
        int i;
        printf("\nStart->");
        for(i=0; i
                printf("(%d,%d)->", path_stack[i].col, path_stack[i].row);
        printf("->end\n\n");
}