八數碼難題---啟發式搜素

1.啟發式搜尋：

特點：重排OPEN表，選擇最有希望的節點加以擴充套件

種類：有序搜尋(A演算法)、A*演算法等

2.估價函式

用來估算節點處於最佳求解路徑上的希望程度的函式

f(n) = g(n) + h(n)

 n——搜尋圖中的某個當前被擴充套件的節點；

f(n) ——從初始狀態節點s, 經由節點n到達目標節點ng，估計的最小路徑代價；

g(n) ——從s到n 的實際路徑代價；

h(n)——從n到ng,估計的最小路徑代價。

 八數碼難題估價函式：f(n)=d(n)+w(n)                     

其中：d(n)為n的深度           w(n)為不在位的棋子數

3.有序搜尋：

選擇OPEN表上具有最小f值的節點作為下一個要擴充套件的節點。

八數碼難題使用全域性擇優搜尋：

   選擇OPEN表上具有最小f值的節點作為下一個要擴充套件的節點，即總是選擇最有希望的節點作為下一個要擴充套件的節點。

在八數碼難題中, 令估價函式

       f(n)=d(n)+p(n)

啟發函式h(n)=p(n),p(n)為不在位的棋子與其目標位置的距離之和，則有p(n)≤h^*(n),滿足A^*演算法的限制條件。

w(n)——不在位的棋子數，不夠貼切，錯誤選用節點加以擴充套件。

p(n)——更接近於h^*(n)的h(n)，其值是節點n與目標狀態節點相比較，每個錯位棋子在假設不受阻攔的情況下，移動到目標狀態相應位置所需走步的總和。

p(n)比w(n)更接近於h^*(n)，因為p(n)不僅考慮了錯位因素，還考慮了錯位的距離（移動次數）

資料結構的建立：由於open，close表常設計刪除增加節點的操作，故使用單鏈表最好

open表儲存生成的節點且未被處理的節點，處理過的節點取出放入close表

close表儲存處理過的節點

status表儲存所有生成的節點

採用全域性擇優的思想

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