c++ maze solver (find every solution) stack overflow

Question

I have an assignment to randomly generate a maze ("weird" ones are valid as well), then I have to find all solutions for the maze (a solution being finding a way from the first row or column to the last row or column), also determine the shortest one. I have this code here, but when I run it, half the time it gives a good answer, the other half time it just exits without any error popup or warning. I guess the reason would be stack overflow. Also, in the assignment it said we had to solve this on a 20x20 maze. If it overflows on a 5x5, can you imagine a 20x20? Anyway, any help would be greatly appreciated. Please ignore the comments, it's actually part of the assignment to have Hungarian comments.

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

struct vector2d {
    int column, row;
};

const int N = 5;        // sorok száma
const int M = 5;        // oszlopok száma
bool ut[N][M];
int count = 0;
int currentLength = 0, minLength = 99999;

void initMaze();         // generál egy labirintust
void printMaze();        // kiiratja a labirintust
int exits();             // kijáratok számát adja vissza
int entrances();         // bejáratok számát adja vissza
bool findPath(int, int); // útkereső eljárás

int main() {
    initMaze();
    printMaze();
    if (exits() > 0 && entrances() > 0) {
        // bactrack
        for (int i = 0; i < M; i++) // vegigjarjuk az elso sor osszes "utjat" es megkeressuk az onnan indulo megoldasokat
            if (ut[0][i])
                if (findPath(0, i)) {
                    count++;
                    if (currentLength < minLength)
                        minLength = currentLength;
                    currentLength = 0;
                }

        for (int i = 1; i < M; i++)
            if (ut[i][0])
                if (findPath(i, 0)) {
                    count++;
                    if (currentLength < minLength)
                        minLength = currentLength;
                    currentLength = 0;
                }
    } else {
        cout << "Maze has no entrances or exits" << endl;
    }

    if (count > 0) {
        cout << count << " solutions for the labyrinth, shortest one is " << minLength << " steps long" << endl;
    } else {
        cout << "Labyrinth has no solution" << endl;
    }

    system("pause");
    return 0;
}

int exits() {
    int count = 0;
    for (int i = 1; i < M - 1; i++)
        if (ut[N - 1][i])
            count++;
    for (int i = 1; i < N - 1; i++)
        if (ut[i][M - 1])
            count++;
    return count;
}

int entrances() {
    int count = 0;
    for (int i = 1; i < M - 1; i++)
        if (ut[0][i])
            count++;
    for (int i = 1; i < N - 1; i++)
        if (ut[i][0])
            count++;
    return count;
}

void initMaze() {
    srand(time(NULL));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++) {
            if (rand() % 3 == 0) // 3-ból egyszer legyen fal
                ut[i][j] = false;
            else
                ut[i][j] = true;
        }
}

void printMaze() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (ut[i][j])
                cout << " - ";
            else
                cout << " | ";
        }
        cout << endl;
    }
}

bool findPath(int row, int column) {
    if (column < 0 || column > N - 1 || row < 0 || row > M - 1) return false;
    if ((column == M - 1 || row == N - 1) && ut[row][column])   return true;
    if (!ut[row][column])                                       return false;
    currentLength++;
    if (findPath(column + 1, row))                              return true;
    if (findPath(column, row + 1))                              return true;
    if (findPath(column - 1, row))                              return true;
    if (findPath(column, row - 1))                              return true;
    currentLength--;
    return false;
}

Oh and also, when the stack overflow occurs, currentLength variable has an unusually high value, 65 thousand something. — Barna Bruder, Mar 27 '15 at 12:23

score 0 · Accepted Answer · answered Mar 27 '15 at 12:28

0

You have the recursive call

findPath(column + 1, row)

This function will after a while come to this recursive call

findPath(column - 1, row)

The problem with these two calls is that will go back to the location it was called from.

For example, if findPath is called with the coordinates 2,4, then the first call shown will call findPath(3,4), which will then call findPath(2,4) (which of course will call findPAth(3,4) and so on and so on in infinity).

answered Mar 27 '15 at 12:28

Some programmer dude

400,186
35
402
621

Wow, thanks for the quick reply. Although I understand the problem, how would I fix it? – Barna Bruder Mar 27 '15 at 12:31
@BarnaBruder Simplest solution is to pass another pair of arguments that is the coordinates of the previous call, and then add check so that you don't go directly back. That will still allow for infinite recursion as you can e.g. then co "left" two places then go "right" two places and you still have the same problem.- Another solution is to use a directed graph for the path, and once you went in one direction you can't go back. There are probably many solutions to this if you read some [graph theory](http://en.wikipedia.org/wiki/Graph_theory). – Some programmer dude Mar 27 '15 at 13:57

c++ maze solver (find every solution) stack overflow

1 Answers1