Esempio n. 1
0
bool SquareMaze::solveMaze_second_helper(int x, int y, vector<int> & path, int dest)
{
	if(x == dest&&y == height -1)
		return true;
	if(canTravel(x, y, 0))
	{
		path.push_back(0);
		setWall(x, y, 0, true);
		if(solveMaze_second_helper(x + 1, y, path, dest))
		{
			setWall(x, y, 0, false);
			return true;
		}
		path.pop_back();
		setWall(x, y, 0, false);
	}
	
	if(canTravel(x, y, 1))
	{
		path.push_back(1);
		setWall(x, y, 1, true);
		if(solveMaze_second_helper(x, y + 1, path, dest))
		{
			setWall(x, y, 1, false);
			return true;
		}
		path.pop_back();
		setWall(x, y, 1, false);
	}
	
	if(canTravel(x, y, 2))
	{		
		path.push_back(2);
		setWall(x - 1, y, 0, true);
		if(solveMaze_second_helper(x - 1, y, path, dest))
		{
			setWall(x - 1, y, 0, false);
			return true;
		}
		path.pop_back();
		setWall(x - 1, y, 0, false);
	}
	
	if(canTravel(x, y, 3))
	{
		path.push_back(3);
		setWall(x, y - 1, 1, true);
		if(solveMaze_second_helper(x, y - 1, path, dest))
		{
			setWall(x, y-1, 1, false);
			return true;
		}
		path.pop_back();
		setWall(x, y - 1, 1, false);
	}
	return false;
}
Esempio n. 2
0
//helper function for solveMaze. Traverses maze and overwrites path & it's 
//length to member variables once successful base case is reached
void SquareMaze::traversal(int x, int y , int length , int cameFrom, 
																				vector<int> path)
{

	//base case: hit bottom
	if (y == (HEIGHT-1) )  
	    	{
			overwriteSolution( path, length, x);
         }              
              
	//base case: hit a dead end
	if( DeadEnd(x, y, cameFrom)  )
		{
		if (y == (HEIGHT-1)) overwriteSolution( path, length, x);
    	return;
    	}
    	
    
//traversal

	//traverse right
	if (canTravel(x, y , 0) && cameFrom !=2)
		{
		path.push_back(0);
		traversal(x+1, y, (length+1), 0, path );
		path.pop_back();
		}

	//traverse down
	if (canTravel(x, y , 1) && cameFrom !=3)
		{
		path.push_back(1);
		traversal(x, y+1, (length+1), 1, path );
		path.pop_back();
		}
	
	//traverse left
	if (canTravel(x, y , 2) && cameFrom !=0)
		{
		path.push_back(2);
		traversal(x-1, y, (length+1), 2, path);
		path.pop_back();
		}
		
	//traverse up	
	if (canTravel(x, y , 3) && cameFrom !=1)
		{
		path.push_back(3);
		traversal(x, y-1, (length+1), 3 , path );
		path.pop_back();
		}
}
Esempio n. 3
0
void SquareMaze::solveMaze_helper(int x, int y, vector<int> & path, int * lastRow)
{
	if(y == height - 1)
		lastRow[x] = path.size();
	if(canTravel(x, y, 0))
	{
		path.push_back(0);
		setWall(x, y, 0, true);
		solveMaze_helper(x + 1, y, path, lastRow);
		path.pop_back();
		setWall(x, y, 0, false);
	}
	
	if(canTravel(x, y, 1))
	{
		path.push_back(1);
		setWall(x, y, 1, true);
		solveMaze_helper(x, y + 1, path, lastRow);
		path.pop_back();
		setWall(x, y, 1, false);
	}
	
	if(canTravel(x, y, 2))
	{		
		path.push_back(2);
		setWall(x - 1, y, 0, true);
		solveMaze_helper(x - 1, y, path, lastRow);
		path.pop_back();
		setWall(x - 1, y, 0, false);
	}
	
	if(canTravel(x, y, 3))
	{
		path.push_back(3);
		setWall(x, y - 1, 1, true);
		solveMaze_helper(x, y - 1, path, lastRow);
		path.pop_back();
		setWall(x, y - 1, 1, false);
	}
	return;
}
Esempio n. 4
0
void Percolation::drawColor(PNG* pic)
{
	for ( int i=0 ;i< Width; i++)
	{	for(int j =0;j<Height; j++)
		{
			for(int k=0;k<4;k++)//k stands for direction  
			{	
				if(canTravel(i,j,k) && dset.find(dsetIndex(i,j))==dset.find(dsetIndex(Width/2,0)) )
					drawSite(pic,i,j,k);

			}
		}
	}


}
Esempio n. 5
0
bool Percolation::percolate(PNG* pic)
{

	queue<site> q;
	q.push(sites[dsetIndex(Width/2,0)]);
	
	site* cur;
	while(!q.empty())	
	{
	
		cur=&q.front();
		q.pop();
		int x=cur->x;
		int y=cur->y;

		if(canTravel(x,y,0) && sites[dsetIndex(x+1,y)].status==false)
		{
			//sites[dsetIndex(x+1,y)].dist=sites[dsetIndex(x,y)].dist+1;
			//sites[dsetIndex(x+1,y)].path=&sites[dsetIndex(x,y)];
			sites[dsetIndex(x+1,y)].status=true;
			q.push(sites[dsetIndex(x+1,y)]);
			//drawSite(pic,x,y,0);
		}	

		if(canTravel(x,y,1) && sites[dsetIndex(x,y+1)].status==false)
		{
			//sites[dsetIndex(x,y+1)].dist=sites[dsetIndex(x,y)].dist+1;
			//sites[dsetIndex(x,y+1)].path=&sites[dsetIndex(x,y)];
			sites[dsetIndex(x,y+1)].status=true;
			q.push(sites[dsetIndex(x,y+1)]);
			//drawSite(pic,x,y,1);
		}	

		if(canTravel(x,y,2) && sites[dsetIndex(x-1,y)].status==false)
		{
			//sites[dsetIndex(x-1,y)].dist=sites[dsetIndex(x,y)].dist+1;
			//sites[dsetIndex(x-1,y)].path=&sites[dsetIndex(x,y)];
			sites[dsetIndex(x-1,y)].status=true;
			q.push(sites[dsetIndex(x-1,y)]);
			//drawSite(pic,x,y,2);
		}	

		if(canTravel(x,y,3) && sites[dsetIndex(x,y-1)].status==false)
		{
			//sites[dsetIndex(x,y-1)].dist=sites[dsetIndex(x,y)].dist+1;
			//sites[dsetIndex(x,y-1)].path=&sites[dsetIndex(x,y)];
			sites[dsetIndex(x,y-1)].status=true;
			q.push(sites[dsetIndex(x,y-1)]);
			//drawSite(pic,x,y,3);
		}	
		sites[dsetIndex(x,y)].status=true;

		
	}//while

	//site* longest;
	//longest=&sites[dsetIndex(0,Height-1)];
	//int best=longest->dist;
	bool result=false;
	
	for(int i=0;i<Width;i++)
	{
		
		if(dset.find(dsetIndex(i,Height-1)) == dset.find(dsetIndex(Width/2,0))  ) 
		{	
			q.push(sites[dsetIndex(i,Height-1)]);
			sites[dsetIndex(i,Height-1)].status=true;
			result= true;
		}
		
	}

	drawColor(pic);
	return result;
}