Issue Implementing A* in C++ with Priority Queues - c++

Question

I'm currently working on a homework assignment to implement A* for the sliding brick puzzle. I have previously implemented BFS and DFS for this puzzle, but an now having problems. I attempted to write my A* code by adapting the BFS code I already had working using a priority queue and Manhattan distance as the heuristic. In order to have the program open the node with the lowest f value (g+h), I had to override the operator for the priority queue, as it contains a defined structure. When I compile the code, no errors arise, but when I run it the program just crashed. My guess is that it is getting stuck in a loop somewhere. Maybe I implemented the operator override incorrectly. Can anyone help me figure out what is going wrong? I have pasted my code below.
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <list>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <time.h>
using namespace std;
struct move //creates structure for a move containing a pice number and direction to move
{
int piece;
char direction;
};
struct parentmove
{
vector< vector<int> > par;
move mo;
};
struct position
{
int row;
int column;
};
struct node
{
vector< vector<int> > par;
vector< vector<int> > state;
position pos;
int g;
int h;
int f;
};
bool operator<(const node& a, const node& b)
{
return a.f > b.f;
}
void SBP::Astar(vector <vector<int> > st)
{
position goalpos = getposition(st, -1);
node stnode;
stnode.state = st;
stnode.g = 0;
position stpos = getposition(st, 2);
stnode.h = abs(goalpos.row - stpos.row) + abs(goalpos.column - stpos.column);
stnode.f = stnode.g + stnode.h;
stnode.pos = stpos;
list<move> allm;
priority_queue< node > unexplored, explored;
set< vector <vector<int> > > closedset; //contains explored states in a set,
map < vector <vector<int> >, parentmove > pathdict;
allm = (*this).allmoves(st);
list<move>::iterator it = allm.begin();
for (int i = 0; i < allm.size(); i++)
{
move m;
m.piece = (*it).piece;
m.direction = (*it).direction;
vector< vector<int> > newst = (*this).applyMove(st, m);
newst = (*this).normalization(newst);
node newnode;
newnode.par = st;
newnode.state = newst;
newnode.g = 1;
position newpos = getposition(newst, 2);
newnode.h = abs(goalpos.row - newpos.row) + abs(goalpos.column - newpos.column);
newnode.f = newnode.h + newnode.g;
newnode.pos = newpos;
unexplored.push(newnode);
parentmove pm = { st,m };
pathdict[newst] = pm;
++it;
}
explored.push(stnode);
closedset.insert(st);
while (!unexplored.empty())
{
node currentnode = unexplored.top();
vector< vector<int> > currentst = currentnode.state;
unexplored.pop();
bool iscomplete = (*this).complete(currentst);
if (iscomplete)
{
explored.push(currentnode);
closedset.insert(currentst);
list<move> path = (*this).constructpath(currentst, pathdict, st);
(*this).display(currentst);
printf("A* explored %i nodes\n", explored.size());
printf("The length of the path solution is %i moves\n", path.size());
return;
}
else
{
set< vector< vector<int> > >::iterator ite = closedset.find(currentst);
if (ite == closedset.end()) //does not already exist in queue
{
list<move> possm;
possm = (*this).allmoves(currentst);
list<move>::iterator iter = possm.begin();
for (int j = 0; j < possm.size(); j++)
{
move m;
m.piece = (*iter).piece;
m.direction = (*iter).direction;
vector< vector<int> > newst = (*this).applyMove(currentst, m);
vector< vector<int> > normst = (*this).normalization(newst);;
node normnode;
normnode.state = normst;
normnode.par = currentst;
normnode.g = currentnode.g + 1;
position p = getposition(normst, 2);
normnode.h = abs(goalpos.row - p.row) + abs(goalpos.column - p.column);
normnode.f = normnode.g + normnode.h;
normnode.pos = p;
unexplored.push(normnode);
if (pathdict.find(normst) == pathdict.end())
{
parentmove pm = { currentst,m };
pathdict[normst] = pm;
}
++iter;
}
explored.push(currentnode);
closedset.insert(currentst);
}
}
}
return;
}