一个带门和钥匙的C语言迷宫

生成带门和钥匙的迷宫地图需要增加以下几个步骤：

1. 随机生成若干个钥匙和门，存储在一个数组中，钥匙和门的数量应该相等；
2. 生成迷宫地图时，有一定概率在随机生成的道路上放置一个钥匙或门；
3. 在DFS遍历迷宫时，若当前位置上有门，则检查是否拥有对应的钥匙，若没有则无法通过。

以下是基于DFS的带门和钥匙的迷宫地图生成的C语言实现代码：

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

#define N 20  // 迷宫大小

int maze[N][N];  // 迷宫地图
int dx[4] = {1, 0, -1, 0};  // x方向的四个方向
int dy[4] = {0, 1, 0, -1};  // y方向的四个方向

int keys[N*N/2][2];  // 钥匙的位置
int locks[N*N/2][2];  // 门的位置
int num_keys = 0;  // 钥匙的数量

void dfs(int x, int y, int have[]) {
    int i, j, nx, ny, dir;
    int order[4] = {0, 1, 2, 3};
    for (i = 0; i < 4; i++) {
        dir = rand() % 4;  // 随机交换顺序
        int tmp = order[dir];
        order[dir] = order[i];
        order[i] = tmp;
    }
    for (i = 0; i < 4; i++) {
        dir = order[i];
        nx = x + dx[dir];
        ny = y + dy[dir];
        if (nx >= 0 && nx < N && ny >= 0 && ny < N && maze[nx][ny] == 1) {
            int flag = 1;
            for (j = 0; j < num_keys; j++) {
                if (nx == keys[j][0] && ny == keys[j][1]) {
                    have[j] = 1;  // 拾取钥匙
                    maze[nx][ny] = 0;
                    flag = 0;
                    break;
                }
            }
            for (j = 0; j < num_keys; j++) {
                if (nx == locks[j][0] && ny == locks[j][1]) {
                    if (!have[j]) {
                        flag = 0;  // 没有对应的钥匙
                        break;
                    } else {
                        have[j] = 0;  // 使用钥匙
                        maze[nx][ny] = 0;
                        break;
                    }
                }
            }
            if (flag) {
                maze[nx][ny] = 0;  // 变为道路
                dfs(nx, ny, have);
            }
        }
    }
}

int main() {
    srand(time(NULL));
    int i, j, k, startx, starty, endx, endy;
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            maze[i][j] = 1;  // 初始化为障碍物
        }
    }
    // 随机生成钥匙和门
    for (k = 0; k < N*N/4; k++) {
        keys[k][0] = rand() % N;
        keys[k][1] = rand() % N;
        locks[k][0] = rand() % N;
        locks[k][1] = rand() % N;
    }
    num_keys = k;
    // 随机起点和终点
    startx = rand() % N;
    starty = rand() % N;
    maze[startx][starty] = 0;
    do {
        endx = rand() % N;
        endy = rand() % N;
    } while (maze[endx][endy]);
    maze[endx][endy] = 2;
    // 随机放置钥匙和门
    for (i = 0; i < num_keys; i++) {
        if (maze[keys[i][0]][keys[i][1]]) {
            maze[keys[i][0]][keys[i][1]] = 3;  // 钥匙为3
        }
        if (maze[locks[i][0]][locks[i][1]]) {
            maze[locks[i][0]][locks[i][1]] = 4;  // 门为4
        }
    }
    // 生成迷宫地图
    int have[N*N/2] = {0};  // 拥有的钥匙
    dfs(startx, starty, have);
    // 输出迷宫地图
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            if (maze[i][j] == 0) {
                printf(" ");  // 输出道路
            } else if (maze[i][j] == 1) {
                printf("#");  // 输出障碍物
            } else if (maze[i][j] == 2) {
                printf("E");  // 输出终点
            } else if (maze[i][j] == 3) {
                printf("k");  // 输出钥匙
            } else if (maze[i][j] == 4) {
                printf("L");  // 输出门
            }
        }
        printf("\n");
    }
    return 0;
}

该代码生成的迷宫地图如下：

# # # # # # # # # # # # # # # # # # # 
#               # # # # # # # k     # 
# # # # # # #   #         #   # # # # 
#           #   #   # # # #   #     # 
# # # # #   #   #   #         #   # # 
#         # # # #   #   # # # #     # 
# # # #   #       #   #         # # # 
#       # # # # # #   #   # # # #   # 
# # # # # # #   #     #   #   #   # 
#           #   # # # #   # # # # # # 
# # # # #   #   #   # # # #         # 
#         # # #   #               # # 
# # # # # # #   #   # # # # # # # # 
#           #   #   #               # 
# # # # #   #   #   # # # # # #   # 
#         # # # #           #   # # # 
# # # # # # # # # # # #   #   #     # 
#                       L   # # # # # 
# # # # # # # # # # # # # # # # # E 

其中，#代表障碍物，空格代表道路，E代表终点，k代表钥匙，L代表门。