ClassNode DepthLimitedDFS(ClassNode Nd, int limit) // Hist olmadan bakınca hızlı bakıyor ama stateler inanılmaz fazla oluyor...
{
ExpCnt++;
int lim = limit;
if (_AreNodesSame(Nd, P.GoalNode))
{
P.IDFSSolved = true;
return(Nd);
}
else if (lim == 0)
{
return(null);
}
lim--;
List <ClassNode> Nsuc = Nd.GetSuccessors();
foreach (ClassNode CNd in Nsuc)
{
ClassNode DumN = DepthLimitedDFS(CNd, lim);
if (DumN != null)
{
return(DumN);
}
}
return(null); // Should not reach here ???
}
public ClassPuzzle SolveIt()
{
ClkSt = DateTime.Now;
Q.Enqueue(P.InitNode);
MaxQ = 1;
Hist.Add(_KeyBuild(P.InitNode), P.InitNode);
while (!P.b_abort && Q.Count > 0)
{
N = Q.Dequeue();
ExpCnt++;
if (_AreNodesSame(N, P.GoalNode))
{
P.BFSSolved = true;
// N is Solution... Search in Hist for it parents till the very beginnig
break;
}
Ns = N.GetSuccessors();
foreach (ClassNode SN in Ns)
{
string key = _KeyBuild(SN);
bool KeyInHist = true; // For Exeption handling when stopping the puzzle solving
try
{ KeyInHist = Hist.ContainsKey(key); }
catch
{ }
if (KeyInHist) // If state already found in hist list, do not do anything
{
}
else // if SN not in Hist List add only successors that are not opened yet
{
Q.Enqueue(SN);
Hist.Add(key, SN);
if (Q.Count > MaxQ)
{
MaxQ = Q.Count;
}
}
}
}
if (P.b_abort)
{
return(P);
}
ClassNode DN = N;
while (DN != null)
{
Sol.Add(DN);
DN = DN.GetParent();
}
Sol.Reverse();
ClkEnd = DateTime.Now;
SolTime = (ClkEnd.Millisecond - ClkSt.Millisecond) + (ClkEnd.Second - ClkSt.Second) * 1000 + (ClkEnd.Minute - ClkSt.Minute) * 60 * 1000 + (ClkEnd.Hour - ClkSt.Hour) * 60 * 60 * 1000 + (ClkEnd.DayOfYear - ClkSt.DayOfYear) * 24 * 60 * 60 * 1000; // DO NOT USE THIS PROGRAM AT NEW YEAR PARTY!!!
P.BFSSolTime = SolTime; // in milli sec
P.BFSNumStoNodes = MaxQ;
P.BFSNumExpNodes = ExpCnt;
P.BFSSolStep = Sol.Count - 1; // It is derived from History List
P.BFSSolSteps = Sol;
return(P);
}
public ClassPuzzle SolveIt()
{
ClassComparer Comp = new ClassComparer();
SortedList <int, ClassNode> L = new SortedList <int, ClassNode>(Comp);
ClkSt = DateTime.Now;
ExpCnt = 0;
N = P.InitNode;
N.Cost = 0;
N.Heur = _CalcHeurMis(N);
L.Add(N.Heur + N.Cost, N);
Hist.Add(_KeyBuild(N), N);
while (!P.b_abort && L.Count > 0)
{
N = L.First().Value;
L.RemoveAt(0);
ExpCnt++; // Node is about to be processed
if (_AreNodesSame(N, P.GoalNode))
{
P.AStarMisSolved = true;
break;
}
Ns = N.GetSuccessors();
foreach (ClassNode SN in Ns)
{
SN.Heur = _CalcHeurMis(SN);
string key = _KeyBuild(SN);
try { KeyInHist = Hist.ContainsKey(key); }
catch { }
if (KeyInHist)
{
try { CostInHistLarger = (Hist[key].Cost > SN.Cost); }
catch { }
if (CostInHistLarger)
{
Hist[key].Cost = SN.Cost;
L.Add(SN.Heur + SN.Cost, SN);
try { LgotLarger = (L.Count > MaxL); }
catch { }
if (LgotLarger)
{
MaxL = L.Count;
}
}
}
else // Then add only successors that are not opened yet
{
L.Add(SN.Heur + SN.Cost, SN);
Hist.Add(key, SN);
try { LgotLarger = (L.Count > MaxL); }
catch { }
if (LgotLarger)
{
MaxL = L.Count;
}
}
}
}
if (P.b_abort)
{
return(P);
}
ClassNode DN = N;
while (DN != null)
{
Sol.Add(DN);
DN = DN.GetParent();
}
Sol.Reverse();
// THEY NEED TO BE CHECKED...
ClkEnd = DateTime.Now;
SolTime = (ClkEnd.Millisecond - ClkSt.Millisecond) + (ClkEnd.Second - ClkSt.Second) * 1000 + (ClkEnd.Minute - ClkSt.Minute) * 60 * 1000 + (ClkEnd.Hour - ClkSt.Hour) * 60 * 60 * 1000 + (ClkEnd.DayOfYear - ClkSt.DayOfYear) * 24 * 60 * 60 * 1000; // DO NOT USE THIS PROGRAM AT NEW YEAR PARTY!!!
P.AStarMisSolTime = SolTime; // in milli sec
P.AStarMisNumStoNodes = MaxL; // Although the History is not used....
P.AStarMisNumExpNodes = ExpCnt;
P.AStarMisSolStep = Sol.Count - 1; // It is derived from History List
P.AStarMisSolSteps = Sol;
return(P);
}
public ClassPuzzle SolveIt()
{
ClkSt = DateTime.Now;
P.InitNode.Cost = 0;
S.Push(P.InitNode);
MaxS++;
Hist.Add(_KeyBuild(P.InitNode), P.InitNode);
while (!P.b_abort && S.Count > 0)
{
N = S.Pop();
ExpCnt++;
if (_AreNodesSame(N, P.GoalNode))
{
P.DFSSolved = true;
break;
}
Ns = N.GetSuccessors();
foreach (ClassNode SN in Ns)
{
string key = _KeyBuild(SN);
bool KeyInHist = true; // For Exeption handling when stopping the puzzle solving
try
{ KeyInHist = Hist.ContainsKey(key); }
catch
{ }
if (KeyInHist) // I wonder whether it works or not
{
// if (Hist[key].Cost > SN.Cost)
// {
// Hist[key].Cost = SN.Cost;
// S.Push(SN);
// if (S.Count > MaxS)
// MaxS = S.Count;
// }
}
else // Then add only successors that are not opened yet
{
S.Push(SN);
Hist.Add(_KeyBuild(SN), SN);
if (S.Count > MaxS)
{
MaxS = S.Count;
}
}
}
}
if (P.b_abort)
{
return(P);
}
ClassNode DN = N;
while (DN != null)
{
Sol.Add(DN);
DN = DN.GetParent();
}
Sol.Reverse();
// THEY NEED TO BE CHECKED...
ClkEnd = DateTime.Now;
SolTime = (ClkEnd.Millisecond - ClkSt.Millisecond) + (ClkEnd.Second - ClkSt.Second) * 1000 + (ClkEnd.Minute - ClkSt.Minute) * 60 * 1000 + (ClkEnd.Hour - ClkSt.Hour) * 60 * 60 * 1000 + (ClkEnd.DayOfYear - ClkSt.DayOfYear) * 24 * 60 * 60 * 1000; // DO NOT USE THIS PROGRAM AT NEW YEAR PARTY!!!
P.DFSSolTime = SolTime; // in milli sec
P.DFSNumStoNodes = MaxS;
P.DFSNumExpNodes = ExpCnt;
P.DFSSolStep = Sol.Count - 1; // It is derived from History List
P.DFSSolSteps = Sol;
return(P);
}
public ClassPuzzle SolveIt()
{
ClkSt = DateTime.Now;
P.IDFSSolved = false; // Since we need to get out of for loop also, I need to set the solved info to false to avoid undesired break after if statement at the very end
MaxS++; // For the very first push
for (int limit = 0; limit < 1000; limit++)
{
S.Clear();
N = P.InitNode;
N.Cost = 0;
S.Push(N);
Hist.Clear(); // Clear Hist for each iteration...
Hist.Add(_KeyBuild(P.InitNode), P.InitNode);
while (!P.b_abort && (S.Count > 0))
{
N = S.Pop();
ExpCnt++;
if (_AreNodesSame(N, P.GoalNode))
{
P.IDFSSolved = true;
break; // That also breaks from for...
}
Ns = N.GetSuccessors();
foreach (ClassNode SN in Ns)
{
string key = _KeyBuild(SN);
// For Exeption handling when stopping the puzzle solving
try
{ KeyInHist = Hist.ContainsKey(key); }
catch
{ }
if (KeyInHist)
{
bool CostInHistLarger = false;
try
{ CostInHistLarger = (Hist[key].Cost > SN.Cost); }
catch
{ }
if (CostInHistLarger)
{
Hist[key].Cost = SN.Cost;
S.Push(SN);
if (S.Count > MaxS)
{
MaxS = S.Count;
}
}
}
else // Then add only successors that are not opened yet
{
try { LimitNotReached = SN.Cost <= limit; }
catch { }
if (LimitNotReached) // 0th node is the init node...
{
S.Push(SN); // So that if cost is larger, it is not pushed in to stack...
Hist.Add(_KeyBuild(SN), SN);
}
try { SgotLarger = (S.Count > MaxS); }
catch { }
if (SgotLarger)
{
MaxS = S.Count;
}
}
}
}
try { PuzzleSolved = (P.IDFSSolved == true); }
catch { }
if (PuzzleSolved)
{
break;
}
}
if (P.b_abort)
{
return(P);
}
ClassNode DN = N;
while (DN != null)
{
Sol.Add(DN);
DN = DN.GetParent();
}
Sol.Reverse();
// THEY NEED TO BE CHECKED...
ClkEnd = DateTime.Now;
SolTime = (ClkEnd.Millisecond - ClkSt.Millisecond) + (ClkEnd.Second - ClkSt.Second) * 1000 + (ClkEnd.Minute - ClkSt.Minute) * 60 * 1000 + (ClkEnd.Hour - ClkSt.Hour) * 60 * 60 * 1000 + (ClkEnd.DayOfYear - ClkSt.DayOfYear) * 24 * 60 * 60 * 1000; // DO NOT USE THIS PROGRAM AT NEW YEAR PARTY!!!
P.IDFSSolTime = SolTime; // in milli sec
P.IDFSNumStoNodes = MaxS;
P.IDFSNumExpNodes = ExpCnt;
P.IDFSSolStep = Sol.Count - 1; // It is derived from History List
P.IDFSSolSteps = Sol;
return(P);
}