Puzzle issues

[elite zero]

I am having an issue with this program. It is running, and seems to be working correctly, however it runs until it uses up all of my memory then crashes. I have a hunch as to what it could be, but I'm not sure. Maybe I'm doing something wrong.

#include <iostream>
#include <string>
#include <map>
#include <queue>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <cctype>
#include <ctype.h>

using namespace std;

// Global Variables
const string goalState = "123456780";	// Solution
string solutionState = "783415602";		// A Working State
string initialState = "123456780";		// Variable for use within Menu()
int counter = 0;						// Counter for node count

// Map / Map Iterator
map <string, int> visited_states;
map <string, int>::iterator it = visited_states.begin();

// Object "node"
struct node
{
	string currentState;	// Holds currentState of this node
	int stateArray[9];		// ? Use substring of current state ?
	int depth;				// Depth of node in tree
	int heuristic;			// How many nodes are out of place
};

// Functions
void Swap0and1(node&);		// Swap Function Prototypes (12)
void Swap0and3(node&);
void Swap1and2(node&);
void Swap1and4(node&);
void Swap2and5(node&);
void Swap3and4(node&);
void Swap4and5(node&);
void Swap4and7(node&);
void Swap5and8(node&);
void Swap6and3(node&);
void Swap6and7(node&);
void Swap7and8(node&);

void randomGenerator();				// Random State Generator
int Check_Goal(node);				// Check for Goal State
void Check_Map(node&);				// Map Check Function
void Expand(node, queue<node>&);	// Expand function
void BFS(node);						// Breadth-First Search Algorithm
void DFS(node);						// Depth-First Search Algorithm
void ASS(node);						// A* w/ Out of Place Algorithm
void Menu();						// Menu Function

void displayPuzzle(string PUZZLE);	// Puzzle Output (Formatted Matrix)

// 1-2-3	0-1-2	Logic Layouts for Matrices
// 4-5-6	3-4-5
// 7-8-0	6-7-8

// Goal State [1,2,3,4,5,6,7,8,0]

//-----------------------------------------------------------------------------

int main()
{
	Menu(); // Menu called for input from User

	system("pause"); // Windows Only Pause

	// cin.ignore(); // Universal Pause
	// cin.get();
	// cout << "Press 'Enter' to continue..." << endl;

	return 0; // Success
}

//-----------------------------------------------------------------------------

void Menu() // Outputs Menu for functionality
{
	int option = NULL;

	cout << " AI Project" << endl;				 
	cout << "------------" << endl << endl;

	cout << "1. Generate Initial State" << endl;
	cout << "2. Breadth-First Search" << endl;
	cout << "3. Depth-First Search" << endl;
	cout << "4. A* Search w/ Out of Place Tiles" << endl;
	cout << "88. Run all Searches (Random States)" << endl;
	cout << "\n0. Exit Program" << endl;

	cout << "\n\n**Note: If you do not choose to generate an initial state ";
	cout << "\nbefore a search, a working state will be chosen for you.**";
	cout << endl << endl;
	cout << ">> ";
	cin >> option;

	if (cin.fail()) option = 99; // Fail safe for non-numeric inputs

	switch (option)
	{
	case 1: 
		randomGenerator(); // Generates a random state w/out repeats

		cout << "\nYour Initial Start State is: " << initialState << endl;
		cout << endl;
		displayPuzzle(initialState); // Output initialState Matrix
		cout << "\nPress 'Enter' to return to the menu" << endl;
		cin.ignore();
		cin.get();
		system("cls");
		Menu();
		break;

	case 2:
		if (initialState == "123456780") // Check for unchosen state
		{
			cout << "\nA state was chosen for you." << endl;
			randomGenerator();
			cout << "Your Initial Start State is: " << initialState << endl;

			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			BFS(initialNode); // Send in initialNode 

			//cout << "Breadth-First Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}
		else
		{
			cout << "\nYour Initial Start State is: " << initialState;
			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			BFS(initialNode); // Send in initialNode

			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}

	case 3:
		if (initialState == "123456780") // Check for unchosen state
		{
			cout << "\nA state was chosen for you." << endl;
			randomGenerator();
			cout << "Your Initial Start State is: " << initialState;

			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			// DFS(initialNode); // Send in initialNode

			cout << "Depth-First Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}
		else
		{
			cout << "\nYour Initial Start State is: " << initialState;
			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			// DFS(initialNode); // Send in initialNode

			cout << "Depth-First Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}

	case 4:
		if (initialState == "123456780") // Check for unchosen state
		{
			cout << "\nA state was chosen for you." << endl;
			randomGenerator();
			cout << "Your Initial Start State is: " << initialState << endl;

			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			// ASS(initialNode); // Send in initialNode

			cout << "A* Search Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}
		else
		{
			cout << "\nYour Initial Start State is: " << initialState;
			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			node initialNode;
			initialNode.currentState = initialState;
			// ASS(initialNode); // Send in initialNode

			cout << "A* Search Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}

	case 88:
		if (initialState == "123456780") // Check for unchosen state
		{
			cout << "\nA state was chosen for you." << endl;
			randomGenerator();
			cout << "Your Initial Start State is: " << initialState << endl;

			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			// This will run all algorithms 10x each with randomly generated
			// states between each search

			cout << "This will run all search algorithms 10x" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}
		else
		{
			cout << "\nYour Initial Start State is: " << initialState;
			cout << endl << endl;
			displayPuzzle(initialState); // Output Matrix

			// Function to call all searches 10x each here

			cout << "Searches Not Created Yet!!!" << endl;
			cout << "Press 'Enter' to return to the menu" << endl;
			cin.ignore();
			cin.get();
			system("cls");
			Menu();
			break;
		}

	case 0:
		cout << "\nExiting the Program..." << endl;
		system("exit"); // Windows Only Pause and Exit
		break;

	default: cout << "\nInput is not valid. Please try again\n\n";
		system("pause");
		cout << endl;
		cin.clear();
		cin.ignore();
		cin.get();
		system("cls"); // Windows Only Clear Screen
		Menu();
		break;

	}//End Switch

}//End void Menu()

//----------------------------------------------------------------------------- 

[elite zero]

void randomGenerator()
{
	srand(time(NULL)); // Seed rand to clock time

	for (int i = 8; i > 0; i--) // Shuffle prevents repeats
	{
		int r = rand() % i;

		int temp = initialState[i]; // Swap i and r
		initialState[i] = initialState[r];
		initialState[r] = temp;
	}

	//displayPuzzle(initialState); // Output initialState Matrix
}

//-----------------------------------------------------------------------------

int Check_Goal(node puzzle)
{
	// Goal State = "123456780"

	if (puzzle.currentState == goalState)
	{
		cout << "Goal State Found after < "<< counter << " > nodes" << endl;
		return 0; // Goal State Found
	}
	else
	{
		//cout << "Not the Goal State" << endl;
		return 1; // Goal State Not Found
	}
}// end void Check_Goal

//-----------------------------------------------------------------------------

void Check_Map(node& puzzle) // Check map for state
{
	// map <string, int> visited_states;

	// Checks map for node and inserts if
	// node doesn't exist in map

	it = visited_states.begin();
	it = visited_states.find(puzzle.currentState);

	// If iterator goes to end, add node, else do nothing

	if (it == visited_states.end()) // If not within map
	{
		counter++;					// Increment counter & add node
		visited_states.insert(pair<string, int>(puzzle.currentState, counter));
	}
	else
	{
		puzzle.currentState.empty();	// Empty node of string
	}
	
}// end void checkMap

//-----------------------------------------------------------------------------

void Expand(node puzzle, queue <node>& currentQueue)
{
	int position = NULL;

	node temp = puzzle;		// Temporarily hold parent node

	for (int i = 0; i < 9; i++)
	{
		// Find '0' within character substring
		if (puzzle.currentState[i] == '0') position = i;
	}

	// After position found, swap positions within node
	// Check the map to see if new positions have been visited
	// If not, empty puzzle.currentState. If currentState is not
	// empty (Swapped position not found in map) push it onto the
	// queue. Move on to next swap, Repeat.
	// Return to Loop and continue.

	switch (position) // Based on '0' position, swaps called
	{
	case 0: 
		Swap0and1(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap0and3(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 1: 
		Swap0and1(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap1and2(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap1and4(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 2:
		Swap2and5(puzzle);
		Check_Map(puzzle);					// Check Map / Insert

		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap1and2(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 3:
		Swap0and3(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap3and4(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap6and3(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 4:
		Swap3and4(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap1and4(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap4and5(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap4and7(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 5:
		Swap2and5(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap4and5(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap5and8(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 6:
		Swap6and3(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap6and7(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 7:
		Swap6and7(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap4and7(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap7and8(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	case 8:
		Swap7and8(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		puzzle = temp;						// Reset puzzle
		Swap5and8(puzzle);
		Check_Map(puzzle);					// Check Map / Insert
		
		if (!puzzle.currentState.empty())	// If node was not within map
		{
			currentQueue.push(puzzle);		// Push node onto queue
		}

		break;

	}// end Swap Switch

}//end void Expand 

[elite zero]

void BFS(node puzzle)	// Breadth-First Search
{
	cout << "Searching for Solution..." << endl << endl;

		/*Generate a starting state.
		Start a counter.
		Put the state and the counter in the Map
		Create a node with the start state and the counter.
		Put the node in the Queue.

		Now we will start a loop

		retrieve the next node in the Queue(If no node then no solution)
		Check for goal state(if goal state we have solution)
		If not goal state locate the 0 in the state
		Determine what nodes are possible to expand based on 0 location
		Do your first swap to create a possible new state
		Check this possible state with what is already in the map
		If its in the map, move on to the next swap
		If its not in the map, increment the counter 
		write the new state to the map
		Create a node for the state and put it in the Queue.
		Continue for all possible swaps.
		Go back to the start of the loop.*/

	counter = 0;
	queue <node> BFSFringe;		// Localized queue
	node temp;				

	Check_Map(puzzle);			// Check / Input Map
	BFSFringe.push(puzzle);		// Push 1st Node to Queue

	while (!BFSFringe.empty())	// Loop for Expansions
	{
		temp = BFSFringe.front();	// Copy node at front of queue
		BFSFringe.pop();			// Pop node from queue

		if (Check_Goal(temp) == 0)	// Check Goal for return
		{
			// Goal found returns 0
			cout << "Breadth-First Search Complete!" << endl;
		}
		else
		{
			// Goal not found returns 1
			Expand(temp, BFSFringe);	// Expand for next node
		}
	}

	if (BFSFringe.empty()) cout << "Queue Empty! No Solution!" << endl;
}

//-----------------------------------------------------------------------------

void DFS(node puzzle)	// Depth-First Search
{
	cout << "Searching for Solution..." << endl << endl;

	counter = 0;
	queue <node> DFSFringe;
	node temp;

	DFSFringe.push(puzzle);		// Initial Node
	counter++;
	Check_Map(puzzle);
	Check_Goal(puzzle);

	while (!DFSFringe.empty())
	{
		temp = DFSFringe.front();
		DFSFringe.pop();
		Expand(temp, DFSFringe);
	}
	if (DFSFringe.empty()) cout << "Queue Empty!" << endl;

}

//-----------------------------------------------------------------------------

void ASS(node puzzle)	// A* Search w/ Heuristic
{
	queue <node> ASSFringe;

	// Expand(temp, ASSFringe);
	// This search algorithm will use cost based on
	// out of place tiles (Heuristic).

}

//-----------------------------------------------------------------------------

void Swap0and1(node& puzzle) // Swap pos 1 and 2
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[0];
	puzzle.currentState[0] = puzzle.currentState[1];
	puzzle.currentState[1] = temp;

	//cout << "After swapping 1 and 2" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap0and3(node& puzzle) // Swap pos 1 and 4
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[0];
	puzzle.currentState[0] = puzzle.currentState[3];
	puzzle.currentState[3] = temp;

	//cout << "After swapping 1 and 4" << endl << endl;
	//displayPuzzle(puzzle.currentState);
}

void Swap1and2(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[1];
	puzzle.currentState[1] = puzzle.currentState[2];
	puzzle.currentState[2] = temp;

	//cout << "After swapping 2 and 3" << endl << endl;
	//displayPuzzle(puzzle.currentState);
}

void Swap1and4(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[1];
	puzzle.currentState[1] = puzzle.currentState[4];
	puzzle.currentState[4] = temp;

	//cout << "After swapping 2 and 5" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap2and5(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[2];
	puzzle.currentState[2] = puzzle.currentState[5];
	puzzle.currentState[5] = temp;

	//cout << "After swapping 3 and 6" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap3and4(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[3];
	puzzle.currentState[3] = puzzle.currentState[4];
	puzzle.currentState[4] = temp;

	//cout << "After swapping 4 and 5" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap4and5(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[4];
	puzzle.currentState[4] = puzzle.currentState[5];
	puzzle.currentState[5] = temp;

	//cout << "After swapping 5 and 6" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap4and7(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[4];
	puzzle.currentState[4] = puzzle.currentState[7];
	puzzle.currentState[7] = temp;

	//cout << "After swapping 5 and 8" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap5and8(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[5];
	puzzle.currentState[5] = puzzle.currentState[8];
	puzzle.currentState[8] = temp;

	//cout << "After swapping 6 and 9" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap6and3(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[6];
	puzzle.currentState[6] = puzzle.currentState[3];
	puzzle.currentState[3] = temp;

	//cout << "After swapping 7 and 4" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap6and7(node& puzzle)
{
	// 0-1-2	Layout for Matrix
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[6];
	puzzle.currentState[6] = puzzle.currentState[7];
	puzzle.currentState[7] = temp;

	//cout << "After swapping 7 and 8" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

void Swap7and8(node& puzzle)
{
	// 0-1-2	Layout for Matrix as substring positions
	// 3-4-5
	// 6-7-8

	int temp = 0;

	temp = puzzle.currentState[7];
	puzzle.currentState[7] = puzzle.currentState[8];
	puzzle.currentState[8] = temp;

	//cout << "After swapping 8 and 0" << endl << endl;
	//displayPuzzle(puzzle.currentState);

}

//-----------------------------------------------------------------------------

void displayPuzzle(string puzzle)
{
	// 0-1-2	Layout for Matrix as substring positions
	// 3-4-5
	// 6-7-8

	cout << " " << puzzle[0] << " - " << puzzle[1] << " - " << puzzle[2] << endl;
	cout << " |" << "   |" << "   |" << endl;
	cout << " " << puzzle[3] << " - " << puzzle[4] << " - " << puzzle[5] << endl;
	cout << " |" << "   |" << "   |" << endl;
	cout << " " << puzzle[6] << " - " << puzzle[7] << " - " << puzzle[8] << endl << endl;

}// end void displayPuzzle() 

[elite zero]

Lol, nevermind. I solved it, guess it took me posting it here to solve it.

This was my issue:

void Check_Map(node& puzzle) // Check map for state
{
	// map <string, int> visited_states;

	// Checks map for node and inserts if
	// node doesn't exist in map

	it = visited_states.begin();
	it = visited_states.find(puzzle.currentState);

	// If iterator goes to end, add node, else do nothing

	if (it == visited_states.end()) // If not within map
	{
		counter++;					// Increment counter & add node
		visited_states.insert(pair<string, int>(puzzle.currentState, counter));
	}
	else
	{
		puzzle.currentState.empty();	// Empty node of string
	}
	
}// end void checkMap 

String.empty() doesn't modify the string, only returns true or false. I needed to use String.clear(). I guess thats what I get for playing with VB and C++ at the same time.

This:
puzzle.currentState.empty(); // Empty node of string

Should be This:

puzzle.currentState.clear(); // Empty node of string