八数码难题（启发式搜索）

package 八数码难题;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class Main {
static int f[][]=new int[3][3];
static int e[][]=new int[3][3];
static int p=0;
static int dir[][]={{0,1},{1,0},{0,-1},{-1,0}};
static List<node>openlist=new LinkedList<node>();
static List<node>closelist=new LinkedList<node>();
static int d=0;
static List<node>status=new LinkedList<node>();
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1;//初始状态
String str2;//目标状态
str1="2831647.5";//空格用.表示
str2="1238.4765";
for(int i=0;i<str1.length();i++){
f[i/3][i-i/3*3]=str1.charAt(i)=='.'?0:str1.charAt(i)-'0';
e[i/3][i-i/3*3]=str2.charAt(i)=='.'?0:str2.charAt(i)-'0';
}
node f1=new node(f,d,e);
openlist.add(f1);
status.add(f1);
Search();//寻找最短路径
toPrint();//输出状态空间
}
public static boolean check(int x,int y){
if(x<0||x>=3||y<0||y>=3){
return false;
}
return true;
}
public static boolean contains(List<node> list,int a[][]){
int flag=0;
int a1[][] = new int[3][3];

for(int i=0;i<list.size();i++){
flag=0;
for(int j=0;j<3;j++){
a1[j]=list.get(i).a[j].clone();
for(int k=0;k<3;k++){
if(a1[j][k]==a[j][k]){
flag++;
}
}
}
if(flag==9) return false;
}
return true;
}
//输出状态空间
public static void toPrint(){
int a[][];
System.out.println();
System.out.println("========状态空间大小为："+status.size()+"-----");
int k1=0,i=0;
while(i<status.size()){
a=status.get(i).a;
System.out.println("---------------");
for(int j=0;j<3;j++){
for(int k=0;k<3;k++){
System.out.print(a[j][k]+" ");
}
System.out.println();
}
i++;
}
}
public static void Search(){
hnode ehn=new hnode(e);
while(!openlist.isEmpty()){
int at[][]=new int[3][3];
int min=0;
for(int i=0;i<openlist.size();i++){
if(openlist.get(i).f<openlist.get(min).f){
min=i;
}
}
node n=null;
n=openlist.remove(min);
closelist.add(n);

for(int i=0;i<3;i++){
at[i]=n.a[i].clone();
}

int x = 0,y = 0;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(at[i][j]==p){
x=i;y=j;//记录空格在棋盘中的位置(原）
break;
}
}
}
for(int i=0;i<4;i++){
int nx,ny,t;
nx=x+dir[i][0];//空格移动的位置（现）
ny=y+dir[i][1];
if(check(nx,ny)){
t=at[nx][ny];
at[nx][ny]=at[x][y];
at[x][y]=t;
d=n.h+1;
hnode thn=new hnode(at);
node tn=new node(at,d,e);
if(thn.equals(ehn)){
//找到最短路径
status.add(tn);
closelist.add(tn);
toOutput();
return;
}

if(contains(openlist,at)&&contains(closelist,at)){
openlist.add(tn);
status.add(tn);
}
t=at[nx][ny];
at[nx][ny]=at[x][y];
at[x][y]=t;
}
}
}
return;
}
public static void toOutput(){
System.out.println("====移动路径如下====");
System.out.println("所需步数为:"+d);
for(int i=0;i<closelist.size();i++){
int a[][]=closelist.get(i).a;
System.out.println("----------------------");
for(int j=0;j<3;j++){
for(int k=0;k<3;k++){
System.out.print(a[j][k]+" ");
}
System.out.println();
}
}
}

}

class hnode{
//hash用于hashSet
int hash;
public hnode(){

}
public hnode(int a[][]){
int hc=0;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
hc*=10;
hc+=a[i][j];
}
}
this.hash=hc;
}
public boolean equals(Object object){
hnode thn=(hnode)object;
return thn.hash==hash;
}
@Override
public int hashCode(){
return hash;
}

}
class node{
int a[][];//九宫格的状态
int h;//深度
int f;//从初始状态节点s, 经由节点n到达目标节点ng，估计的最小路径代价
int p;//不在位的棋子与其目标位置的距离之和
public node(int [][]a,int h,int [][]e){
this.a=new int[3][];
for(int i=0;i<3;i++){
this.a[i]=a[i].clone();
}
this.h=h;
this.p=work(e);
this.f=this.h+this.p;
}
public int work(int e[][]){
int ants=0;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(a[i][j]!=e[i][j]&&a[i][j]!=0){
int r=0,c = 0,flag=0;
for(int k=0;k<3;k++){
for(int k1=0;k1<3;k1++){
if(a[i][j]==e[k][k1]){
r=k;
c=k1;
ants+=Math.abs(r-i);
ants+=Math.abs(c-j);
flag=1;
break;
}
}
if(flag==1) break;
}

}
}
}
return ants;
}
}