/* -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

C + + source code of the eight digital

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - */

# include & lt; Iostream>
# include & lt; Ctime>
# include & lt; Vector>
using namespace std;

Const int ROW=3;
Const int COL=3;
Const int MAXDISTANCE=10000;
Const int MAXNUM=10000;

Typedef struct _Node {
Int digit [ROW] [COL];
Int dist.//short between one state and the destination
Int dep.//the the depth of the node
//So the comment function=dist + dep.
Int index;//point to the location of the parent
} the Node;

The Node SRC, dest;

Vector Node_v;//store the nodes

Bool isEmptyOfOPEN () {
for (int i=0; I & lt; Node_v. The size (); I++) {
If (node_v [I]. Dist.=MAXNUM)
return false;
}
return true;
}

Bool isEqual (int index, int digit [] [COL]) {
for (int i=0; I & lt; The ROW. I++)
For (int j=0; J & lt; COL. J++) {
If (node_v [index]. Digit [I] [j].=digit [I] [j])
return false;
}
return true;
}

Ostream& Operator<(ostream& OS, Node& The node) {
for (int i=0; I & lt; The ROW. I++) {
For (int j=0; J & lt; COL. J++)
OS & lt; OS & lt; }
Return the OS;
}

Void PrintSteps (int index, vector & Rstep_v) {
Rstep_v. Push_back (node_v [index]);
The index=node_v [index]. Index;
While (index!=0) {
Rstep_v. Push_back (node_v [index]);
The index=node_v [index]. Index;
}

For (int I=rstep_v. The size () - 1; I & gt;=0; I -)
Cout & lt; <"Step" & lt; }

Void Swap (int& A, int& B) {
Int t;
T=a;
A=b;
B=t;
}

Void the Assign (Node& The node, int index) {
for (int i=0; I & lt; The ROW. I++)
For (int j=0; J & lt; COL. J++)
Node. Digit [I] [j]=node_v [index] digit [I] [j];
}

Int GetMinNode () {
Int dist=MAXNUM;
Int loc;//the location of minimize the node
for (int i=0; I & lt; Node_v. The size (); I++) {
If (node_v [I]. Dist==MAXNUM)
continue;
Else if ((node_v [I]. Dist + node_v [I] dep) & lt; Dist) {
Loc=I;
Dist=node_v [I]. Dist + node_v [I]. Dep.
}
}

Return the loc;
}

Bool isExpandable (Node& The node) {
for (int i=0; I & lt; Node_v. The size (); I++) {
If (isEqual (I, node. Digit))
return false;
}
return true;
}

Int short (Node& The node, int digit [] [COL]) {
Int short=0;
Bool flag=false;
for(int i=0; I & lt; The ROW. I++)
For (int j=0; J & lt; COL. J++)
For (int k=0; K & lt; The ROW. K++) {
For (int l=0; L & lt; COL. L++) {
If (node. Digit [I] [j]==digit [k] [l]) {
Short +=abs (I - k) + abs (j - l);
flag=true;
break;
}
The else
Flag=false;
}
If (flag)
break;
}
Return short;
}

Int MinDistance (int a, int b) {
Return (a & lt; b ? A: b);
}

Void ProcessNode (int index) {
Int x, y;
Bool flag;
for (int i=0; I & lt; The ROW. I++) {
For (int j=0; J & lt; COL. J++) {
If (node_v [index]. Digit [I] [j]==0) {
X=I; Y=j;
flag=true;
break;
}
The else flag=false;
}
If (flag)
break;
}

The Node node_up;
The Assign (node_up, index);
Int dist_up=MAXDISTANCE;
If (x & gt; 0 {
Swap (node_up digit [y], [x] node_up. Digit [1] x [y]);
If (isExpandable (node_up)) {
Dist_up=short (node_up, dest. Digit);
Node_up. Index=index;
Node_up. Dist=dist_up;
Node_up. Dep=node_v [index]. Dep + 1;
Node_v. Push_back (node_up);
}
}

The Node node_down;
The Assign (node_down, index);
Int dist_down=MAXDISTANCE;
If (x & lt; 2) {
Swap (node_down digit [y], [x] node_down. Digit [x + 1] [y]);
If (isExpandable (node_down)) {
Dist_down=short (node_down, dest. Digit);
Node_down. Index=index;
Node_down. Dist=dist_down;
Node_down. Dep=node_v [index]. Dep + 1;
Node_v. Push_back (node_down);
}
}

The Node node_left;
The Assign (node_left, index);
Int dist_left=MAXDISTANCE;
If (y & gt; 0 {
Swap (node_left digit [y], [x] node_left. Digit [x] [1] y);
If (isExpandable (node_left)) {
Dist_left=short (node_left, dest. Digit);
Node_left. Index=index;
Node_left. Dist=dist_left;
Node_left. Dep=node_v [index]. Dep + 1;
Node_v. Push_back (node_left);
}
}

The Node node_right;
The Assign (node_right, index);
Int dist_right=MAXDISTANCE;
If (y & lt; 2) {
Swap (node_right digit [y], [x] node_right. Digit [x] [y + 1));
If (isExpandable (node_right)) {
Dist_right=short (node_right, dest. Digit);
Node_right. Index=index;
nullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnull