public ClassPuzzle SolveIt() { ClkSt = DateTime.Now; ExpCnt = 0; N = P.InitNode; ClassNode DNd; for (int i = 1; i < 250000; i++) { Hist.Clear(); Hist.Add(_KeyBuild(P.InitNode), P.InitNode); //Console.WriteLine("Iteration: {0}", i.ToString()); DNd = DepthLimitedDFS(P.InitNode, i); if (DNd != null) { N = DNd; break; } } 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 = MaxHist; // Although the History is not used.... P.IDFSNumExpNodes = ExpCnt; P.IDFSSolStep = Sol.Count - 1; // It is derived from History List P.IDFSSolSteps = Sol; return(P); }
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); }