带有DFS的c中的迷宫生成算法

Question

recently i read this topic about generating mazes in c . see here https://www.algosome.com/articles/maze-generation-depth-first.html and i want to write it in c . here is my code and it's not working right .

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int check[5][5];
int v[5][5];
int border(int x , int y ){
    if(x> -1 && x< 6 && y > -1 && y<6)
        return 1;
    else
        return 0 ;
}
int wall[6][6][6][6];
void dfs ( int x , int y){
    srand(time(NULL));
    int s = 1/*rand() % 4 ;*/ ;
    if(s=1 ){
        if(border(x ,y-1)&& check[x][y-1]==0){
            check[x][y]=1;
            wall[x][y][x+1][y]=1;
            dfs(x , y-1);
        }
        else
            return ;
    }
    else if(s=2){
        if(border(x+1 ,y)&&check[x+1][y]==0){
            check[x][y]=1;
            wall[x+1][y][x+1][y+1]=1;
            dfs(x+1 , y);
        }
        else return ;
    }
    else if(s=3){
        if(border(x ,y+1)&&check[x][y+1]==0){
            check[x][y]=1;
            wall[x][y+1][x+1][y+1]=1;
            dfs(x , y+1);
        }
        else return ;
    }
    else if(s=0){
        if(border(x-1 ,y)&&check[x-1][y]==0){
            check[x][y]=1;
            wall[x][y][x][y+1]=1;
            dfs(x-1 , y);
        }
        else return ;
    }
return ;
}

int main(){
dfs( 4, 4);
for(int i =0 ; i < 6 ; i++)
    for (int j =0 ; j < 6 ; j++)
        for ( int h =0 ; h <6 ; h++)
            for (int k =0 ; k < 6 ; k ++)
                printf("%d \n" , wall[i][j][h][k]);

return 0 ;
}

i invert my table to graph , and i want to show me the coordinates of my walls . what's the problem ?

Answer 1

You have several errors – programming errors and logic errors – in your code:

• When you distiguish between the directions the s=1 and so on should be s == 1 . You want a comparison, not an assignment. (Your code is legal C, so there is no error.)
• You call srand at the beginning of dfs , which you call recursively. This will make your single (commented) rand call always create the same random number. You should seed the pseudo random number generator only once at the beginning of main .
• You can store the paths the way you do, but it is wasteful. There are only four possible paths from each cell, so you don't need an array that allows to create a path between (0,0) and (3,4), for example.
• Your code would benefit from using constants or enumerated values instead of the hard-coded 5's and 6's. This will allow you to change the dimensions later easily.

But your principal error is in how you implement the algorithm. You pick one of the for directions at random, then test whether that direction leads to a valid unvisited cell. If so, you recurse. If not, you stop. This will create a single unbranched path through the cells. Note that if you start in a corner cell, you have already a 50% chance of stopping the recursion short.

But you want something else: You want a maze with many branches that leads to every cell in the maze. Therefore, when the first recursion returns, you must try to branch to other cells. The algorithm goes like this:

• Make a list of all possible exits.
• If there are possible exits:
  • Pick one exit, create a path to that exit and recurse.
  • Update the list of possible exits.

Note that you cannot re-use the old list of exits, because the recursion may have rendered some possible exits invalid by visiting the destination cells.

Below is code that creates a maze with the described algorithm. I've used two distinct arrays to describe horizontal and vertical paths:

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

enum {
    W = 36,         // width of maze
    H = 25          // height of maze
};

enum {
    North,
    East,
    South,
    West,
    NDir
};

char visited[H][W];
char horz[H][W - 1];        // horizontal E-W paths in the maze
char vert[H - 1][W];        // veritcal N-S paths in the maze

/*
 *      Fill dir with directions to unvisited cells, return count
 */
int adjacent(int dir[], int x, int y)
{
    int ndir = 0;

    if (y > 0     && visited[y - 1][x] == 0) dir[ndir++] = North;
    if (x < W - 1 && visited[y][x + 1] == 0) dir[ndir++] = East;
    if (y < H - 1 && visited[y + 1][x] == 0) dir[ndir++] = South;
    if (x > 0     && visited[y][x - 1] == 0) dir[ndir++] = West;

    return ndir;
}

/*
 *      Traverse cells depth first and create paths as you go
 */
void dfs(int x, int y)
{
    int dir[NDir];
    int ndir;

    visited[y][x] = 1;

    ndir = adjacent(dir, x, y);

    while (ndir) {
        int pick = rand() % ndir;

        switch (dir[pick]) {
        case North: vert[y - 1][x] = 1; dfs(x, y - 1); break;
        case East:  horz[y][x] = 1;     dfs(x + 1, y); break;
        case South: vert[y][x] = 1;     dfs(x, y + 1); break;
        case West:  horz[y][x - 1] = 1; dfs(x - 1, y); break;
        }

        ndir = adjacent(dir, x, y);
    }
}

/*
 *      Print a map of the maze
 */
void map(void)
{
    int i, j;

    for (i = 0; i < W; i++) {
        putchar('_');
        putchar('_');
    }

    putchar('\n');

    for (j = 0; j < H; j++) {
        putchar('|');

        for (i = 0; i < W; i++) {
            putchar(j < H - 1 && vert[j][i] ? ' ' : '_');
            putchar(i < W - 1 && horz[j][i] ? '_' : '|');
        }

        putchar('\n');
    }
}

int main()
{
    srand(time(NULL));

    dfs(0, 0);
    map();

    return 0;
}

You can test it here . If you replace the while in dsf with a simple if , you get more or less what you implemented. Note that this creates only a single, usually short path.