Функция поиска не работает

Я пытаюсь иметь алгоритм, который делает DFA для игры в крестики-нолики. С кодом у меня сейчас есть повторяющиеся состояния. Я сделал функцию поиска, чтобы увидеть, было ли состояние уже перед его добавлением, и добавил уже созданное состояние в вектор родительского состояния потомков.

Я пытался реализовать его, но я все еще получаю то же количество узлов, которое получал до того, как реализовал его, что означает, что он никогда не найдет другое состояние с таким же массивом ‘position’, как предполагается. Я не понимаю, что я делаю не так. Это никогда ничего не возвращает.

ОБНОВЛЕНИЕ: я знаю, что это возвращается в ближайшее время и не проходит через все элементы, но я не знаю, как заставить это пройти через все состояния и заставить это прекратить возвращаться слишком рано.

ОБНОВЛЕНИЕ 2.0: Таким образом, я изменил, где мой поиск, теперь он находится в моем файле Main.cpp. Я также изменил, как это проходит, но это все еще не возвращается правильно.

Есть идеи? Вот мой код:

States.cpp

#include "States.hpp"
State::State(){
final = false;
reject = false;
draw = false;
for (int i = 0; i < 9; i++)
_position[i] = 2;
firstPlayerMove = true;
_children = new vector<State *> ();
};

void State::setStateChildren(State *s){
_children->push_back(s);
}
vector<State*> *State::getChildren(){
return _children;

}

void State::setFirstMove(bool b){
firstPlayerMove = b;
}

bool State::firstMove(){
return firstPlayerMove;
}

void State::setPosition(int p[]){

for (int i = 0; i < 9; i++){
_position[i] = p[i];

}

}

int *State::position(){
return _position;
}bool State::isFinal(){
return final;
}

bool State::isReject(){
return reject;
}

main.cpp

#include <iostream>
#include <vector>
#include "States.hpp"
using namespace std;

void dependents(State *root, State *state, bool first);
int size (State *s);
bool win(int p[], int symbol);
bool draw(int p[]);void CreateDFA(State *root, State *state, int n){
if (n == 0 || state == nullptr)
return;
if (state->isFinal() || state->isReject() || state->isDraw())
return;
dependents(root, state, state->firstMove());
for (vector<State*>::iterator iter = state->getChildren()->begin(); iter != state->getChildren()->end(); iter++){
CreateDFA(root, *iter, n - 1);
}
}

void dependents(State *root, State *state, bool first){
int symbol;
if (first)
symbol = 1;
else
symbol = 0;
int count = 0;
while (count < 9){
if (state->position()[count] == 2 && state->position()[count] != 1 && state->position()[count] != 0){
int check[9];
for(int i = 0; i < 9; i++)
check[i] = state->position()[i];
check[count] = symbol;
State *child = root->find(root, check);
if (child == nullptr){
child = new State();
child->setPosition(state->position());
child->setFirstMove(!(state->firstMove()));
child->position()[count] = symbol;
child->setFinal(win(child->position(), 1));
child->setReject(win(child->position(), 0));
child->setDraw(draw(child->position()));
}

state->setStateChildren(child);
}
count++;
}
}

bool win(int p[], int symbol){
if(p[0] == symbol && p[1] == symbol && p[2] == symbol)
return true;
if(p[0] == symbol && p[4] == symbol && p[8] == symbol)
return true;
if(p[0] == symbol && p[6] == symbol && p[3] == symbol)
return true;
if(p[1] == symbol && p[4] == symbol && p[7] == symbol)
return true;
if(p[2] == symbol && p[4] == symbol && p[6] == symbol)
return true;
if(p[2] == symbol && p[5] == symbol && p[8] == symbol)
return true;
if(p[3] == symbol && p[4] == symbol && p[5] == symbol)
return true;
if(p[6] == symbol && p[7] == symbol && p[8] == symbol)
return true;
return false;
}

bool draw(int p[]){
if(p[0] != 2 && p[1] != 2 && p[2] != 2 && p[3] != 2 && p[4] != 2 && p[5] != 2 && p[6] != 2 && p[7] != 2 && p[8] != 2){
cout << "Set Draw" << endl;
return true;
}
return false;

}

int size (State *s){
if (s == nullptr)
return 0;
int count = 0;
for(vector<State*>::iterator iter = s->getChildren()->begin(); iter != s->getChildren()->end(); iter++)
count = size(*iter) + count;
return count + 1;
}

bool check(int p[], int a[]){
for(int i = 0; i < 9; i++)
if (p[i] != a[i])
return false;
return true;
}State *find(State * root, int p[]){
if (root->isFinal() || root->isReject() || root->isDraw())
return nullptr;
State * s = nullptr;
for (vector<State*>::iterator iter = root->getChildren()->begin(); iter != root->getChildren()->end(); iter++){
if(check((*iter)->position(), p)){
s = new State (**iter);
break;
}
else
s = find((*iter), p);
}
return s;
}