關於迷宮求解問題（八個方向）

數據結構課程線性結構的一個作業叫作迷宮求解問題，是對於DFS和BFS的考察與應用，

之前在網上找，C語言的都只有四個方向，而這道題要求八個方向，難度更大一些，

把代碼放在這（比較粗糙），方便自己以后復習。

迷宮求解要求：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include<malloc.h>
#define LEN 200

int top;
int** maze;//maze為迷宮
int** mark;//mark記錄該點是否經過，初值為0，每經過一次加1
int m, n;//m為迷宮行數，n為迷宮列數
int mov[9][3] = { {0,0,0},{0,0,1},{0,1,1},{0,1,0},{0,1,-1},{0,0,-1},{0,-1,-1},{0,-1,0},{0,-1,1} };
typedef struct body
{
    int i;
    int j;
    int v;
}body;
body* s;

void produce_maze()//生成迷宮並且初始化mark
{
    srand((unsigned)time(NULL));
    int i, j, t;
    int flag = -1;
    char c;
    printf("請輸入迷宮的行數和列數：");
    scanf_s("%d %d", &m, &n);
    maze = (int**)malloc(sizeof(int*) * (m + 2));
    for (i = 0; i < m + 2; i++)
    {
        maze[i] = (int*)malloc(sizeof(int) * (n + 2));
    }
    mark = (int**)malloc(sizeof(int*) * (m + 2));
    for (i = 0; i < m + 2; i++)
    {
        mark[i] = (int*)malloc(sizeof(int) * (n + 2));
    }
    for (i = 0, t = m + 1, j = 0; j < n + 2; j++)
    {
        maze[i][j] = 1;
        maze[t][j] = 1;
    }
    for (i = 1, j = 0, t = n + 1; i < m + 1; i++)
    {
        maze[i][j] = 1;
        maze[i][t] = 1;
    }
    while ((flag != 1) && (flag != 0))
    {
        printf("隨機生成請按1，手動生成請按0\n");
        scanf_s("%d", &flag);
    }
    switch (flag)
    {
    case 1:

        for (i = 1; i < m + 1; i++) //隨機生成迷宮
        {
            for (j = 1; j < n + 1; j++)
            {
                maze[i][j] = rand() % 2;
                mark[i][j] = 0;
            }
        }
        break;
    case 0:
        printf("請輸入迷宮（0表示能通過，1表示不能通過）：\n");
        for (i = 1; i < m + 1; i++) //手動生成迷宮
        {
            for (j = 1; j < n + 1; j++)
            {
                scanf_s(" %c", &c);
                maze[i][j] = c - '0';
                mark[i][j] = 0;
            }
        }
        printf("\n");
        break;
    default:
        ;
    }
    printf("已生成!\n");
    printf("\n");
}

//void setmark()
//{
//    int i, j;
//    for (i = 1; i < m + 1; i++)
//    {
//        for (j = 1; j < n + 1; j++)
//        {
//            mark[i][j] = 0;
//        }
//    }
//}
void setstack()//建立一個長為m*n的棧
{
    s = (body*)malloc(sizeof(body) * m * n);//0~mn-1
    memset(s, 0, sizeof(body) * m * n);
    top = 0;
}

void Push(int a, int b, int c)
{
    top++;
    s[top].i = a;
    s[top].j = b;
    s[top].v = c;
}

body Pop()
{
    return s[top];
}

void output(body* s)
{
    int i;
    for (i = 1; i <= top; i++) {
        printf("i=%d,j=%d,v=%d\n", s[i].i, s[i].j, s[i].v);
    }
}

int Empty()//top的值等於棧內元素的個數
{
    if (top <= 0)
        return 1;
    else
        return 0;
}

void printmaze()//打印迷宮
{
    int i, j;
    printf("迷宮如下：\n");
    for (i = 0; i < m + 2; i++)
    {
        for (j = 0; j < n + 2; j++)
        {
            printf("%d ", maze[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int DG_maze(int a, int b, int c)//迷宮求解的遞歸算法
{
    if ((maze[a][b] == 1) || (mark[a][b] == 1))
    {
        printf("無路徑！\n");
        exit(0);
    }
    if ((a == m) && (b == n))
    {
        printf("遞歸法，路徑如下:\n");
        output(s);
        printf("\n");
        return 0;
    }
    if ((maze[a][b + 1] == 0) && (mark[a][b + 1] == 0))
    {
        mark[a][b] = 1;
        c = 1;
        Push(a, b, c);
        DG_maze(a, b + 1, c);
        return 0;
    }
    if ((maze[a + 1][b + 1] == 0) && (mark[a + 1][b + 1] == 0))
    {
        mark[a][b] = 1;
        c = 2;
        Push(a, b, c);
        DG_maze(a + 1, b + 1, c);
        return 0;
    }
    if ((maze[a + 1][b] == 0) && (mark[a + 1][b] == 0))
    {
        mark[a][b] = 1;
        c = 3;
        Push(a, b, c);
        DG_maze(a + 1, b, c);
        return 0;
    }
    if ((maze[a + 1][b - 1] == 0) && (mark[a + 1][b - 1] == 0))
    {
        mark[a][b] = 1;
        c = 4;
        Push(a, b, c);
        DG_maze(a + 1, b - 1, c);
        return 0;
    }
    if ((maze[a][b - 1] == 0) && (mark[a][b - 1] == 0))
    {
        mark[a][b] = 1;
        c = 5;
        Push(a, b, c);
        DG_maze(a, b - 1, c);
        return 0;
    }
    if ((maze[a - 1][b - 1] == 0) && (mark[a - 1][b - 1] == 0))
    {
        mark[a][b] = 1;
        c = 6;
        Push(a, b, c);
        DG_maze(a, b + 1, c);
    }
    if ((maze[a - 1][b] == 0) && (mark[a - 1][b] == 0))
    {
        mark[a][b] = 1;
        c = 7;
        Push(a, b, c);
        DG_maze(a - 1, b, c);
        return 0;
    }
    if ((maze[a - 1][b + 1] == 0) && (mark[a - 1][b + 1] == 0))
    {
        mark[a][b] = 1;
        c = 8;
        Push(a, b, c);
        DG_maze(a - 1, b + 1, c);
        return 0;
    }
    else
    {
        a = Pop().i;
        b = Pop().j;
        c = Pop().v;
        top--;
        DG_maze(a, b, c);
        return 0;
    }
}

int UDG_maze()//非遞歸算法
{
    int minlength = LEN;
    int a;
    int b;
    int x = 1;
    int y = 1;//xy表橫縱坐標
    int z = 1;//表方向
    int flag = 0;//表有幾條通路
    mark[1][1] = 1;
    printf("分析結果如下：\n");
    if (maze[x][y] == 1)
    {
        printf("迷宮無入口到出口的路經\n");
        return 0;
    }
    do
    {
        a = x + mov[z][1];
        b = y + mov[z][2];
        if ((maze[a][b] == 0) && (mark[a][b] == 0))
        {
            Push(x, y, z);
            mark[a][b] = 1;
            if ((a == m) && (b == n))
            {
                output(s);
                minlength = (minlength > top ? top : minlength);
                printf("\n");
                printf("***************************\n");
                flag++;
                mark[a][b] = 0;
                top--;
                z++;
            }
            else
            {
                x = a;
                y = b;
                z = 1;
            }
        }
        else
        {
            if (z < 8)
                z++;
            else
            {
                if (top > 0)
                {
                    do {
                        mark[x][y] = 0;
                        x = Pop().i;
                        y = Pop().j;
                        z = Pop().v;
                        z++;
                        top--;
                    } while (z > 8);//連續退棧時要注意每一次都要將該點的mark清零！（頭禿啊~~qwq）
                }
                else
                {
                    mark[x][y] = 0;
                    continue;
                }
            }
        }
    } while (mark[1][1]);
    if (!flag)
    {
        
        printf("迷宮無入口到出口的路經\n");
    }
    else
    {
        printf("共%d條通路\n", flag);
        printf("其中最短路徑長為%d\n", minlength);
    }
}

int main()
{
    int menu;
    int status;
    produce_maze();
    printmaze();
    setstack();
    printf("請選擇遞歸算法or非遞歸算法：（遞歸算法按1，非遞歸算法按0）\n");
    scanf_s("%d", &menu);
    if (menu == 1)
    {
        status = DG_maze(1, 1, 0);
    }
    else if (menu == 0)
    {
        status = UDG_maze();
    }
    else printf("輸入錯誤~親，重來一次吧~");
    free(maze);
    free(mark);
    return 0;
}

這應該不算一篇正式的文章，等寒假再認真寫寫。