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;
}
