static bool searchRecur(Edge* e, int size, int currentPoint, int prevPoint, int* previousPoints, int nbPreviousPoints){
bool returnRecur = false;
// Pour chaque arête du tableau et tant qu'on a pas de retour à vrai
for (int i=0; i<size && returnRecur == false; i++){
// Si on trouve une arête du type (pointActuel, pointDifferentDuPrecedent)
if (e[i]->start == currentPoint && e[i]->end != prevPoint){
// On regarde si on a déjà traversé cette ville
if (isInArray(e[i]->end, previousPoints, nbPreviousPoints))
return true;
// Sinon, on avance vers la prochaine ville
previousPoints[nbPreviousPoints] = e[i]->end;
nbPreviousPoints++;
returnRecur = searchRecur(e, size, e[i]->end, e[i]->start, previousPoints,nbPreviousPoints);
// On retire la ville des villes visitées
nbPreviousPoints--;
}
// Si on trouve une arête du type (pointDifferentDuPrecedent, pointActuel)
else if (e[i]->end == currentPoint && e[i]->start != prevPoint){
if (isInArray(e[i]->start, previousPoints, nbPreviousPoints))
return true;
previousPoints[nbPreviousPoints] = e[i]->start;
nbPreviousPoints++;
returnRecur = searchRecur(e, size, e[i]->start,e[i]->end, previousPoints,nbPreviousPoints);
nbPreviousPoints--;
}
}
return returnRecur;
}
bool searchRecur(string word, int start, TrieNode* node) {
if(word.empty()) return root->finish;
int n = word.size();
for(int i = start; i < n; i++) {
if(word[i] != '.') {
int idx = word[i] - 'a';
if(node->child[idx] == NULL) {
return false;
}
node = node->child[idx];
} else {
for(int j = 0; j < N; j++) {
if(node->child[j] == NULL) {
continue;
}
if(searchRecur(word, i + 1, node->child[j])) {
return true;
}
}
return false;
}
}
return node->finish;
}
SearchDir::SearchDir(const char* path)
{
m_head.m_name = path;
//get detail information of directory
searchRecur(&m_head);
}
// isCyclic
// Les variables sont représentés ainsi.
// e : la route actuelle
// actual : nombre de villes dans la route actuellement
// size : la taille de la route max : le nombre maximum de villes
// edge : l'arête à tester si elle forme un cycle
//
// isCyclic vérifie si une arête selectionnée permet de créer un cycle entre 3 points au moins.
static bool isCyclic(Edge* e, int actual, int size, int max, Edge edge){
// On ajoute temporairement l'arête au tableau
e[actual] = edge;
int previousPoints[size];
int nbPreviousPoints = 0;
// Pour chaque ville
for (int i=0; i<max; i++){
// Pour chaque arête de la route actuelle
for (int j=0; j<actual+1; j++){
// Pour une arête (u, v) de la route, si u correspond à une ville
if (e[j]->start == i) {
// On traverse la ville
*(previousPoints + nbPreviousPoints) = e[j]->start;
nbPreviousPoints++;
// Puis on teste tous les chemins possibles prenant la route actuelle et la ville actuelle,
// pour vérifier qu'aucun cycle existe
if(searchRecur(e, actual+1, e[j]->end, e[j]->start, previousPoints,nbPreviousPoints)){
return true;
}
// On retire la ville des villes visitées
nbPreviousPoints--;
}
// Pour une arête (u, v) de la route, si v correspond à une ville
else if (e[j]->end == i){
*(previousPoints + nbPreviousPoints) = e[j]->end;
nbPreviousPoints++;
if(searchRecur(e, actual+1, e[j]->start, e[j]->end, previousPoints,nbPreviousPoints)){
return true;
}
nbPreviousPoints--;
}
}
}
e[actual] = NULL;
return false;
}
// Returns if the word is in the trie.
bool search(string word) {
if(word.empty()) return root->finish;
return searchRecur(word, 0, root);
}