Painfully slow maze making program - c++

Question

I am writing a program that generates any size maze you want. It does this by first creating every cell in the maze and assuming they are entirely walled in. They are each declared as their own set. Then a random cell is selected and then a random direction to break down a wall. The random direction funcion makes sure that its also a valid direction for that cell. The program makes sure that the two cells its looking to join arent already connected somehow and if they arent it breaks the wall. If they are already connected either directly or indirectly then it selects a new random cell and direction. This continues until the number of sets left is just 1 ensuring that you can get from any point in the maze to any other point. The program works but it is painfully slow. I dont think it should be as slow as it is and I am unsure why.
I can imagine a scenario where all the cells are connected but one. Thus it would take a little while to randomly select that one cell and that could slow things down but I would imagine when you are dealing with under 100,000 cells it still shouldn't take as long as it does. Rand should be prettu fast at spitting out numbers.
Ive attatched my code below. Its fairly simple but I am sorry about the lack of notes.
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;
class dset {
struct element {
element() { rank=0, parent=-1; }
int rank;
int parent;
vector<int> connections;
};
public:
dset(int nr=0,int nc=0);
int size() {return Nsets; }
int merge (int, int);
int find(int);
// Functions
bool isin(int i, vector<int> test);
int randdir(int i);
int randcell();
int dir(int, int);
void print();
vector<int> possibledir(int cell);
vector<int> walls(int cell, vector<int> possible);
private:
int Nsets;
int nrows, ncols;
vector<element> S;
};
int main(int argc, char* argv[]){
int nrows, ncols, cell, direction;
if (argc != 3){
cout << "Usage: nrows ncols\n";
}
stringstream convert;
convert << argv[1];
convert << " ";
convert << argv[2];
convert >> ncols;
convert >> nrows;
dset maze(nrows,ncols);
srand(time(NULL));
while(maze.size() != 1){
cell = maze.randcell();
// cell = 11;
direction = maze.randdir(cell);
// direction = 0;
// cout << "cell: " << cell << " direction: " << direction << " new cell: " << maze.dir(cell, direction) <<endl << endl;
// cout << maze.size() << endl<<endl;;
maze.merge(cell, maze.dir(cell, direction));
}
maze.print();
}
dset::dset(int nr,int nc) {
nrows = nr;
ncols = nc;
int N = (nrows * ncols);
if (0<N) S.insert(S.end(), N, element());
Nsets = N;
}
void dset::print(){
vector<int> wall;
cout << "MAZE " << nrows << " " << ncols << endl;
for ( int i = 0; i < (nrows*ncols); i++ ){
wall = walls(i,possibledir(i));
for( int j = 0; j < wall.size(); j++){
if (i < wall[j])
cout << i << " " << wall[j] << endl;
}
}
}
int dset::randcell(){
return (rand()%(nrows*ncols));
}
int dset::dir(int cell, int direction){
if(direction == 0)
return (cell - 1);
if(direction == 1)
return (cell - (ncols));
if(direction == 2)
return (cell+1);
if(direction == 3)
return (cell + ncols);
}
int dset::randdir(int i){
srand(time(NULL));
int direction;
vector<int> used;
//cout << "i : " << i << endl;
while (true){
direction = rand() % 4;
while (true){
if(isin(direction,used))
direction = rand()%4;
else
break;
}
// cout << "rand: " << direction << endl;
if(direction ==0){
if( i != 0){
// cout << 0 << " i%(ncols -1) :" << (i%(ncols -1)) << endl;
if(i%(ncols) != 0){
break;
}
}
}
if(direction == 1){
// cout << 1 << " i - ncols :" << (i-ncols) << endl;
if(i-ncols > 0){
break;
}
}
if (direction == 2){
// cout << 2 << " i%(ncols) :" << (i%ncols) << endl;
if ( i == 0 )
break;
if (i%ncols != ncols-1){
break;
}
}
if (direction == 3){
if (i+ncols < ((nrows*ncols))){
// cout << 3 << " i+ncols :" << (i+ncols) << endl;
break;
}
}
used.push_back(direction);
}
return direction;
}
vector<int> dset::possibledir(int cell){
vector<int> possible;
// cout << "cell " << cell << " possible connections:\n";
for (int i = 0; i < 4; i++){
if (i == 0){
if( cell != 0 ){
if(cell%(ncols) !=0){
// cout << dir(cell,i) <<endl;
possible.push_back(dir(cell,i));
}
}
}
if(i==1){
if (cell-ncols > 0){
// cout<<dir(cell,i) <<endl;
possible.push_back(dir(cell,i));
}
}
if(i==2){
if(cell == 0){
// cout<<dir(cell,i) <<endl;
possible.push_back(1);
}else if(cell%ncols != ncols-1){
// cout<<dir(cell,i) <<endl;
possible.push_back(dir(cell,i));
}
}
if(i==3){
if ( cell+ncols < ((nrows*ncols))){
// cout<<dir(cell,i) <<endl;
possible.push_back(dir(cell,i));
}
}
}
// cout << endl;
return possible;
}
vector<int> dset::walls(int cell, vector<int> possible){
vector<int> walls;
// cout << cell << " connection 0: " << S[cell].connections[0] << endl;
for(int i = 0; i < possible.size(); i++){
if (!isin(possible[i], S[cell].connections)){
// cout << "true\n";
walls.push_back(possible[i]);
}
// cout << "false\n";
}
return walls;
}
int dset::merge(int i, int j) {
int cell1 = i;
int cell2 = j;
i = find(i);
j = find(j);
if (i != j) {
element &Si = S[i];
element &Sj = S[j];
// Adjust Adjacency List
// cout << "inconnections\n";
S[cell1].connections.push_back(cell2);
S[cell2].connections.push_back(cell1);
// cout << "notinconnections\n";
// merge (union) by rank
if (Si.rank > Sj.rank) Sj.parent = i;
else if (Si.rank < Sj.rank) Si.parent = j;
else { Sj.parent = i; Si.rank +=1; }
Nsets -=1;
}
return find(i);
}
int dset::find(int i) {
if (S[i].parent == -1){
return i;
}
// recursive path compression
S[i].parent = find(S[i].parent);
return S[i].parent;
}
bool dset::isin(int i, vector<int> test){
bool out = false;
for(int j = 0; j < test.size(); j++){
if(test[j] == i)
out = true;
}
return out;
}

Answer 1

Please learn to pass by reference, not value.
For example:
bool dset::isin(int i, vector<int> test)
You are passing a vector by value. That means that an entire copy is made when the function is called. If your vector has 100,000 items, then an unnecessary copy is made. Change to this:
bool dset::isin(int i, vector<int>& test)
Now no copy is done. Make this same change in all of your other functions.
You also return a vector by value, but I would leave those alone unless it is proven that your compiler can't or won't optimize the copy away.
Also, make sure you are timing a release, optimized program, and not a "debug" or unoptimized program. Since you didn't mention the compiler you're using, use the settings that generate optimized code when building your program.

Answer 2

Although I do not know much about c++, it would seem to me from your program description at the start that your slowdown may happen when your program is determining whether two prospectively connectable cells are already connected. Since the majority if not all cases when this is done that are used must determine that the cells are NOT connected, so that there is only one proper solution, every time this is done your program has to examine/solve the entire maze to that point to make sure that there is no way in which it could already be connected. This means that as the existing part of the maze gets larger, the time it takes to complete this task will get longer and longer.
To test whether this is the case, you could have your program record how long it takes to determine if two cells are connected every time ( or 10 times) it does so, and if the times on the list get longer linearly, then this or something similar is part of the issue.
You could fix this by either allowing already-connected to be connected by another path, or by simplifying the way in which your program checks what cells are connected.
Sorry I can't give better code-specific advice, but I'm researching how to create a maze and ran across your question, hopefully my answer at least is food for thought.