public HidatoGrid.Node GetPrevNode(HidatoGrid.Node current) { int cost = current.Data; HidatoGrid.Node MinCostNode = null; for (int i = 0; i < m_history.Count; i++) { int CurrentCost; HidatoGrid.Node CurrentNode = m_history[i]; CurrentCost = current.Data - CurrentNode.Data; if (CurrentCost < cost) { cost = CurrentCost; MinCostNode = CurrentNode; } if (CurrentCost <= 0) { break; } } m_history.Remove(MinCostNode); return(MinCostNode); }
private HidatoGrid.Node FindNextNode(HidatoGrid.Node current) { //다음노드 HidatoGrid.Node nextnode = FindFirstNode(); //현재노드 HidatoGrid.Node nNode; //최대값 지역변수를 선언한 다음 미리 구해놓은 맴버 변수(maxval변수)에서 값을 가져옴 int maxval = this.maxval; if (current.data == HidatoGrid.Node.unused) { return(null); } for (int i = 0; i < GridClength; i++) { for (int j = 0; j < GridRlength; j++) { //현재 위치의 노드; nNode = m_hidatoGrid.GetNodeAt(i, j); //현재 위치의 노드의 값이 매개변수로 넘어온 노드보다 크면서 //최대값보다 작으면 if (nNode.data > current.data && nNode.data <= maxval) { maxval = nNode.data; nextnode = nNode; } } } return(nextnode); }
public int GetDataAt(int Yindex, int Xindex) { HidatoGrid.Node taget = m_hidatoGrid.GetNodeAt(Yindex, Xindex); int TagetData = taget.data; return(TagetData); }
private HidatoGrid.Node FindMinPossibe() { NodeOfHidatoGridList.Sort(delegate(HidatoGrid.Node c1, HidatoGrid.Node c2) { return(c1.Data.CompareTo(c2.Data)); }); //구간의 시작부분과 마지막 부분을 저장하는 변수 HidatoGrid.Node start = null; HidatoGrid.Node end = null; HidatoGrid.Node minNode = null; HidatoGrid.Node nextNodeOfminNode = null; int size = maxval; for (int i = 0; i < NodeOfHidatoGridList.Count; i++) { //현재 노드 HidatoGrid.Node currentNode = NodeOfHidatoGridList[i]; if (currentNode.Data == 0) { NodeOfHidatoGridList.Remove(currentNode); continue; } else { if (start == null) { start = currentNode; } else if (end == null) { end = currentNode; //if() if (end.Data - start.Data < size && end.Data - start.Data > 1) { //모든 면이 둘러사여 있어 애초에 불가능한 구간은 건너뜀 if (FindOption(start).SizeOfnumSet() != 0) { size = end.Data - start.Data; minNode = start; nextNodeOfminNode = end; } } start = end; end = null; } } } //NextNode = nextNodeOfminNode; return(minNode); }
private void InitList() { for (int i = 0; i < m_hidatoGrid.GridClength; i++) { for (int j = 0; j < m_hidatoGrid.GridRlength; j++) { HidatoGrid.Node nNode = m_hidatoGrid.GetNodeAt(i, j); if (nNode.Data > 0) { NodeOfHidatoGridList.Add(nNode); } } } }
public void AddNode(HidatoGrid.Node node) { //while(current.next != null) //{ // current = current.next; //} history.Node temp = new history.Node(); temp.node = node; current.next = temp; temp.prev = current; current = current.next; }
private HidatoGrid.Node FindFirstNode() { for (int i = 0; i < GridClength; i++) { for (int j = 0; j < GridRlength; j++) { HidatoGrid.Node temp = m_hidatoGrid.GetNodeAt(i, j); if (temp.data == 1) { return(temp); } } } return(null); }
public bool startsolve() { current = FirstNode = FindFirstNode(); HintStack.Push(FirstNode); maxval = FindMaxVal(); history = new history(); history.AddNode(current); NextNode = FindNextNode(current); HintStack.Push(NextNode); if (solve()) { return(true); } else { return(false); } }
public void Startsolve(Hidato_Board board) { SolveCancel = false; m_isProcess = true; DateTime dtstart = DateTime.Now; current = FirstNode = FindFirstNode(); maxval = FindMaxVal(); history = new history(); NextNode = FindNextNode(current); InitList(); SmartSuch = false; EmptyNodeCount = maxval - HintCount(); if (SmartSuch == true) { current = FindMinPossibe(); } RefBoard = board; DTNextUpdate = DTNextUpdate.AddSeconds(NextUpdateSoconds); bool success = Solve(); m_isProcess = false; if (success && !SolveCancel) { RefBoard.ShowSFdialog(true, dtstart); return; } else if (success && SolveCancel) { return; } else { RefBoard.ShowSFdialog(false, dtstart); return; } }
public void SetDataAt(int Yindex, int Xindex, int data) { HidatoGrid.Node taget = m_hidatoGrid.GetNodeAt(Yindex, Xindex); taget.data = data; }
private bool solve() { show(); PrevNode = HintStack.Peek(); bool PrevNodeIsPossible = ChekPrevPossibleVal(current); if (HintStack.Peek().data != NextNode.data) { HintStack.Push(FindNextNode(current)); PrevNode = HintStack.Peek(); } if (current.data == NextNode.data - 1 && NextNode.data != maxval) { if (PrevNodeIsPossible == true) { current = NextNode; hidatoCount = current.data; NextNode = FindNextNode(current); } else { if (InsertCount < 50) { InsertCount++; } else if (HowManyExitStack >= PossibleHowManyExitStack) { HowManyExitStack = 1; InsertCount = 0; } else { HowManyExitStack++; InsertCount = 0; } StackCount = 1; if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } if (current.data != PrevNode.data) { current.data = 0; } current = history.GetPrevElement().node; hidatoCount = current.data; return(false); } } } else if (current.data == maxval - 1 && ChekPrevPossibleVal(current)) { return(true); } if ((current != NextNode) && (current.data == NextNode.data)) { if (InsertCount < 50) { InsertCount++; } else if (HowManyExitStack >= PossibleHowManyExitStack) { HowManyExitStack = 1; InsertCount = 0; } else { HowManyExitStack++; InsertCount = 0; } StackCount = 1; if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } if (PrevNode.data != current.data) { current.data = 0; } current = history.GetPrevElement().node; hidatoCount = current.data; return(false); } } SurchMarking marker = FindOption(current); if (marker.sizeOfnumSet() == 0) { if (InsertCount < 50) { InsertCount++; } else if (HowManyExitStack >= PossibleHowManyExitStack) { HowManyExitStack = 1; InsertCount = 0; } else { HowManyExitStack++; InsertCount = 0; } StackCount = 1; if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } if (PrevNode.data != current.data) { current.data = 0; } current = history.GetPrevElement().node; hidatoCount = current.data; return(false); } } //SurchMarking marker1 = ChekPrevNodeCorrectVal(NextNode); //8개의 인접한 칸에 뭐가 있으면서도(0이 아니면) 이전노드보다 1이 작지 않으면 for (int i = 0; i < 8; i++) { while (StackCount < HowManyExitStack) { StackCount++; if (current.data != 1) { current.data = 0; current = history.GetPrevElement().node; hidatoCount = current.data; return(false); } } if (marker.SurchMarker[(int)side.N] == true) { //HowManyTry++; //현재노드를 북쪽으로 설정한 다음 current = current.N; hidatoCount++; current.data = hidatoCount; history.AddNode(current); //이미 탐색한 자리임으로 false마킹 marker.SurchMarker[(int)side.N] = false; } else if (marker.SurchMarker[(int)side.NE] == true) { //HowManyTry++; current = current.NE; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.NE] = false; } else if (marker.SurchMarker[(int)side.E] == true) { //HowManyTry++; current = current.E; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.E] = false; } else if (marker.SurchMarker[(int)side.SE] == true) { //HowManyTry++; current = current.SE; history.AddNode(current); hidatoCount++; current.data = hidatoCount; marker.SurchMarker[(int)side.SE] = false; } else if (marker.SurchMarker[(int)side.S] == true) { //HowManyTry++; current = current.S; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.S] = false; } else if (marker.SurchMarker[(int)side.SW] == true) { //HowManyTry++; current = current.SW; history.AddNode(current); marker.SurchMarker[(int)side.SW] = false; hidatoCount++; current.data = hidatoCount; } else if (marker.SurchMarker[(int)side.W] == true) { //HowManyTry++; current = current.W; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.W] = false; } else if (marker.SurchMarker[(int)side.NW] == true) { //HowManyTry++; current = current.NW; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.NW] = false; } else { if (InsertCount < 50) { InsertCount++; } else if (HowManyExitStack >= PossibleHowManyExitStack) { InsertCount = 0; HowManyExitStack = 1; } else { HowManyExitStack++; InsertCount = 0; } StackCount = 1; if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } if (PrevNode.data != current.data) { current.data = 0; } current = history.GetPrevElement().node; hidatoCount = current.data; return(false); } else { continue; } } //if(solve())와 같은 표현 if (solve() == true) { return(true); } } return(false); }
public void AddNode(HidatoGrid.Node node) { this.m_history.Add(node); m_history.Sort(delegate(HidatoGrid.Node c1, HidatoGrid.Node c2) { return(c1.Data.CompareTo(c2.Data)); }); }
private bool ChekPrevPossibleVal(HidatoGrid.Node current) { if (current.N != null) { if (current.data + 1 == current.N.data) { return(true); } } if (current.NE != null) { if (current.data + 1 == current.NE.data) { return(true); } } if (current.E != null) { if (current.data + 1 == current.E.data) { return(true); } } if (current.SE != null) { if (current.data + 1 == current.SE.data) { return(true); } } if (current.S != null) { if (current.data + 1 == current.S.data) { return(true); } } if (current.SW != null) { if (current.data + 1 == current.SW.data) { return(true); } } if (current.W != null) { if (current.data + 1 == current.W.data) { return(true); } } if (current.NW != null) { if (current.data + 1 == current.NW.data) { return(true); } } return(false); }
private SurchMarking FindOption(HidatoGrid.Node current) { SurchMarking marker = new SurchMarking(); //현재 노드의 윗부분(북쪽)이 쓰지 않는 부분이거나(비대칭시 사용), 윗부분이 없거나, 뭐가 차있으면 if (current.N == null) { marker.SurchMarker[(int)side.N] = false; } else if (current.N.data == HidatoGrid.Node.unused || current.N.data > 0) { //사용 할 수없다는 표시를 함 marker.SurchMarker[(int)side.N] = false; } else//아니면 { marker.SurchMarker[(int)side.N] = true; } if (current.NE == null) { marker.SurchMarker[(int)side.NE] = false; } else if (current.NE.data == HidatoGrid.Node.unused || current.NE.data > 0) { marker.SurchMarker[(int)side.NE] = false; } else { marker.SurchMarker[(int)side.NE] = true; } if (current.E == null) { marker.SurchMarker[(int)side.E] = false; } else if (current.E.data == HidatoGrid.Node.unused || current.E.data > 0) { marker.SurchMarker[(int)side.E] = false; } else { marker.SurchMarker[(int)side.E] = true; } if (current.SE == null) { marker.SurchMarker[(int)side.SE] = false; } else if (current.SE.data == HidatoGrid.Node.unused || current.SE.data > 0) { marker.SurchMarker[(int)side.SE] = false; } else { marker.SurchMarker[(int)side.SE] = true; } if (current.S == null) { marker.SurchMarker[(int)side.S] = false; } else if (current.S.data == HidatoGrid.Node.unused || current.S.data > 0) { marker.SurchMarker[(int)side.S] = false; } else { marker.SurchMarker[(int)side.S] = true; } if (current.SW == null) { marker.SurchMarker[(int)side.SW] = false; } else if (current.SW.data == HidatoGrid.Node.unused || current.SW.data > 0) { marker.SurchMarker[(int)side.SW] = false; } else { marker.SurchMarker[(int)side.SW] = true; } if (current.W == null) { marker.SurchMarker[(int)side.W] = false; } else if (current.W.data == HidatoGrid.Node.unused || current.W.data > 0) { marker.SurchMarker[(int)side.W] = false; } else { marker.SurchMarker[(int)side.W] = true; } if (current.NW == null) { marker.SurchMarker[(int)side.W] = false; } else if (current.NW.data == HidatoGrid.Node.unused || current.NW.data > 0) { marker.SurchMarker[(int)side.NW] = false; } else { marker.SurchMarker[(int)side.NW] = true; } return(marker); }
private bool Solve() { #if DEBUG //디버그 할 때만 할당되는 모니터링용 변수 int CurrentData = current.Data; #endif if (SolveCancel) { return(true); } bool PrevNodeIsPossible = ChekPrevPossibleVal(current); current.marker = FindOption(current); //비어있는 칸이 더 이상 없으면 if (EmptyNodeCount == 0) { //풀린 것 return(true); } //현재 노드의 데이터가 다음 노드의 데이터보다 1이 작고, 다음 노드가 최댓값이 아니면서 #region 현재 노드와 NextNode가 실제로 붙어 있는지 검사 if (current.Data == NextNode.Data - 1 && PrevNodeIsPossible == true) { //지금 현재 노드와 다음 노드가 붙어 있으면 history.AddNode(current); if (SmartSuch == true) { current = FindMinPossibe(); NextNode = FindNextNode(current); } else { //NextNode를 업데이트하고 현재 노드를 업데이트 전의 NextNode로 바꿈 current = NextNode; hidatoCount = current.Data; NextNode = FindNextNode(current); } if (Solve()) { return(true); } } else if (current.Data == NextNode.Data - 1 && PrevNodeIsPossible == false) { if (current.Data != 1) { //현재 노드의 작업 공간(worksace)를 0으로 설정하고,(변경사항 없음 이라고 표시) 바로 이전 노드로 되돌림 HidatoGrid.Node prevNode = history.GetPrevNode(current); current.WorkSapce = 0; current.EmptyMarker(); //애초에 빈 노드이므로 EmptyNodecount를 1증가시킴 if (current.Input == 0) { EmptyNodeCount++; } current = prevNode; //HidatoCount변수를 바꾼 현재 노드의 데이터로 설정한 후 hidatoCount = current.Data; //NextNode를 업데이트 함 NextNode = FindNextNode(current); #region 모니터링 하기 위해 업데이트 하는 부분 if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } #endregion #if DEBUG HoWManyExit++; Console.WriteLine(""); Console.WriteLine("{0}", EmptyNodeCount); Console.WriteLine("{0}", maxval - HintCount()); Console.WriteLine("{0}", HoWManyExit); #endif return(false); } } if ((current.Data == NextNode.Data) && (current != NextNode)) { if (current.Data != 1) { HidatoGrid.Node prevNode = history.GetPrevNode(current); current.WorkSapce = 0; current.EmptyMarker(); if (current.Input == 0) { EmptyNodeCount++; } current = prevNode; hidatoCount = current.Data; //NextNode를 업데이트 함 NextNode = FindNextNode(current); #region 모니터링 하기 위해 업데이트 하는 부분 if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } #endregion return(false); } } if (current.marker.SizeOfnumSet() == 0) { if (current.Data != 1) { //현재 노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 HidatoGrid.Node prevNode = history.GetPrevNode(current); current.WorkSapce = 0; current.EmptyMarker(); if (current.Input == 0) { EmptyNodeCount++; } current = prevNode; //HidatoCount변수를 바꾼 현재 노드의 데이터로 설정한 후 hidatoCount = current.Data; //NextNode를 업데이트 함 NextNode = FindNextNode(current); #region 모니터링 하기 위해 업데이트 하는 부분 if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } #endregion return(false); } } #endregion for (int i = 0; i < 8; i++) { bool InsertSuccess = false; for (int j = 0; j < 8; j++) { if (current.marker.SurchMarker[insertNow.Current] == true) { hidatoCount = current.Data; //이미 탐색한 자리임으로 false마킹 history.AddNode(current); #region 이미 탐색한 자리는 false로 마킹 if (insertNow.Current == (int)Side.N) { current.marker.SurchMarker[(int)Side.N] = false; } else if (insertNow.Current == (int)Side.NE) { current.marker.SurchMarker[(int)Side.NE] = false; } else if (insertNow.Current == (int)Side.E) { current.marker.SurchMarker[(int)Side.E] = false; } else if (insertNow.Current == (int)Side.SE) { current.marker.SurchMarker[(int)Side.SE] = false; } else if (insertNow.Current == (int)Side.S) { current.marker.SurchMarker[(int)Side.S] = false; } else if (insertNow.Current == (int)Side.SW) { current.marker.SurchMarker[(int)Side.SW] = false; } else if (insertNow.Current == (int)Side.W) { current.marker.SurchMarker[(int)Side.W] = false; } else if (insertNow.Current == (int)Side.NW) { current.marker.SurchMarker[(int)Side.NW] = false; } #endregion #region current참조를 알맞은 위치로 옮김 if (insertNow.Current == (int)Side.N) { current = current.N; } else if (insertNow.Current == (int)Side.NE) { current = current.NE; } else if (insertNow.Current == (int)Side.E) { current = current.E; } else if (insertNow.Current == (int)Side.SE) { current = current.SE; } else if (insertNow.Current == (int)Side.S) { current = current.S; } else if (insertNow.Current == (int)Side.SW) { current = current.SW; } else if (insertNow.Current == (int)Side.W) { current = current.W; } else if (insertNow.Current == (int)Side.NW) { current = current.NW; } #endregion NodeOfHidatoGridList.Add(current); hidatoCount++; current.WorkSapce = hidatoCount; //비어있는 칸이 1칸 줄어들기 때문에 1을 줄여야 합니다. EmptyNodeCount--; #region 모니터링 하기 위해 업데이트 하는 부분 if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } #endregion InsertSuccess = true; break; } insertNow.Increase(); } if (!InsertSuccess) { if (current.Data != 1) { //아니면, 현재 노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 HidatoGrid.Node prevNode = history.GetPrevNode(current); current.WorkSapce = 0; current.EmptyMarker(); if (current.Input == 0) { EmptyNodeCount++; } current = prevNode; //HidatoCount변수를 바꾼 현재 노드의 데이터로 설정한 후 hidatoCount = current.Data; NextNode = FindNextNode(current); #region 모니터링하기 위해 업데이트 하는 부분 if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } #endregion return(false); } else { continue; } } if (ShowAllProcess == true) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); Thread.Sleep(ProcessWaitTime); } else if (DateTime.Now > DTNextUpdate) { RefBoard.UpdateTextBoxes(); DTNextUpdate = DateTime.Now.AddSeconds(NextUpdateSoconds); } if (Solve() == true) { return(true); } } return(false); }
private bool solve() { ///디버그 하기 쉽게 출력을 시켜줌 show(); int DataOfCurrentNode = current.data; PrevNode = HintStack.Peek(); bool PrevNodeIsPossible = ChekPrevPossibleVal(current); ///HintStack의 맨 위에 있는 노드의 데이타가 다음 노드의 데이타와 같지 않으면 if (HintStack.Peek().data != NextNode.data) { ///현재 노드의 다음 노드를 찾아서 집어넣음 HintStack.Push(FindNextNode(current)); ///이전 노드는 힌트 스텍의 맨 위쪽 PrevNode = HintStack.Peek(); } SurchMarking marker = FindOption(current); ///현재 노드의 데이터가 다음 노드의 데이터보다 1이 작고, 다음 노드가 최대값이 아니면서 if (current.data == NextNode.data - 1 && NextNode.data != maxval) { ///바로 이전 노드가 올바르면(붙어 있으면) if (PrevNodeIsPossible == true) { //NextNode를 업데이트하고 현재 노드를 업데이트 전의 NextNode로 바꿈 current = NextNode; hidatoCount = current.data; NextNode = FindNextNode(current); history.AddNode(current); if (solve()) { return(true); } } else //그렇지 않으면 { ///InsertCount를 +1하고, if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } //현재 노드가 힌트와 겹치면(히다토에서 미리 정해져 있는 상수) if (current.data == PrevNode.data) { //바로 이전 노드로 되돌리기만함 current = history.GetPrevElement().node; } else { //아니면, 현재노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 current.data = 0; current = history.GetPrevElement().node; } //HidatoCount변수를 바꾼 현재노드의 데이터로 설정한 후 hidatoCount = current.data; //NextNode변수를 업데이트 하고 NextNode = FindNextNode(current); hidatoCount = current.data; return(false); } } } else if (current.data == maxval - 1 && PrevNodeIsPossible == true) { return(true); } if (current.data == NextNode.data - 1 && PrevNodeIsPossible == false) { if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } //현재 노드가 힌트와 겹치면(히다토에서 미리 정해져 있는 상수) if (current.data == PrevNode.data) { //바로 이전 노드로 되돌리기만함 current = history.GetPrevElement().node; } else { //아니면, 현재노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 current.data = 0; current = history.GetPrevElement().node; } //HidatoCount변수를 바꾼 현재노드의 데이터로 설정한 후 hidatoCount = current.data; NextNode = FindNextNode(current); return(false); } } if ((current != NextNode) && (current.data == NextNode.data)) { if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } current.data = 0; current = history.GetPrevElement().node; hidatoCount = current.data; NextNode = FindNextNode(current); hidatoCount = current.data; return(false); } } if (marker.sizeOfnumSet() == 0) { if (current.data != 1) { //PrevNode변수는 HintStack에 가장 윗 부분이다.HintStack의 가장 윗부분은 NextNode임으로(다음 노드임으로) if (PrevNode.data > current.data) { //가장 윗부분을 덜어낸 다음 HintStack.Pop(); //덜어낸 스택의 가장 윗부분을 이전 노드로 설정 PrevNode = HintStack.Peek(); } //현재 노드가 힌트와 겹치면(히다토에서 미리 정해져 있는 상수) if (current.data == PrevNode.data) { //바로 이전 노드로 되돌리기만함 current = history.GetPrevElement().node; } else { //아니면, 현재노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 current.data = 0; current = history.GetPrevElement().node; } //HidatoCount변수를 바꾼 현재노드의 데이터로 설정한 후 hidatoCount = current.data; //바로 NextNode를 업데이트 하고 NextNode = FindNextNode(current); return(false); } } //SurchMarking marker1 = ChekPrevNodeCorrectVal(NextNode); //8개의 인접한 칸에 뭐가 있으면서도(0이 아니면) 이전노드보다 1이 작지 않으면 for (int i = 0; i < 8; i++) { if (marker.SurchMarker[(int)side.N] == true) { //현재노드를 북쪽으로 설정한 다음 current = current.N; hidatoCount++; current.data = hidatoCount; history.AddNode(current); //이미 탐색한 자리임으로 false마킹 marker.SurchMarker[(int)side.N] = false; } else if (marker.SurchMarker[(int)side.NE] == true) { current = current.NE; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.NE] = false; } else if (marker.SurchMarker[(int)side.E] == true) { current = current.E; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.E] = false; } else if (marker.SurchMarker[(int)side.SE] == true) { current = current.SE; history.AddNode(current); hidatoCount++; current.data = hidatoCount; marker.SurchMarker[(int)side.SE] = false; } else if (marker.SurchMarker[(int)side.S] == true) { current = current.S; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.S] = false; } else if (marker.SurchMarker[(int)side.SW] == true) { current = current.SW; history.AddNode(current); hidatoCount++; current.data = hidatoCount; marker.SurchMarker[(int)side.SW] = false; } else if (marker.SurchMarker[(int)side.W] == true) { //HowManyTry++; current = current.W; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.W] = false; } else if (marker.SurchMarker[(int)side.NW] == true) { //HowManyTry++; current = current.NW; hidatoCount++; current.data = hidatoCount; history.AddNode(current); marker.SurchMarker[(int)side.NW] = false; } else { if (current.data != 1) { if (PrevNode.data > current.data) { HintStack.Pop(); PrevNode = HintStack.Peek(); } //현재 노드가 힌트와 겹치면(히다토에서 미리 정해져 있는 상수) if (current.data == PrevNode.data) { //바로 이전 노드로 되돌리기만함 current = history.GetPrevElement().node; } else { //아니면, 현재노드의 데이터를 0으로 설정하고,(비워놓음) 바로 이전 노드로 되돌림 current.data = 0; current = history.GetPrevElement().node; } //HidatoCount변수를 바꾼 현재노드의 데이터로 설정한 후 hidatoCount = current.data; return(false); } else { continue; } } //if(solve())와 같은 표현 if (solve() == true) { return(true); } } return(false); }
public void InputAt(int Yindex, int Xindex, int data) { HidatoGrid.Node taget = GetNodeAt(Yindex, Xindex); taget.Input = data; }