从拼图游戏开始(四)_IDA*算法求解Java实现

       终于，在学习了完深搜和广搜、Dijkstra、二叉堆和优先队列以及A*算法之后，可以看一下IDA*算法了。因为求解4x4的拼图游戏所要搜素的节点数很大，所以应该采用IDA*算法，而3x3的拼图游戏则可以采用A*算法。

       IDA*算法是A*的一个变形，和A*算法不同的是他不保存之前的搜索状态(意味着同一个节点可能会被搜索多次)，它的搜索效率会稍微低于A*算法。笔者对于IDA*的翻译是迭代深度的A*算法，它是一种有信息提示的搜索(informed search)，但其实现思想是基于无信息提示的IDDFS(iterative deepening depth-first search)。

下面先来讨论IDDFS,再来实现基于IDDFS的IDA*。

       打开维基百科,发现没有中文版的介绍。于是笔者只能用咱的蹩脚英语翻译一下了：

      <译>Iterative deepening depth-first search (IDDFS)是一个反复调用depth-limited search的状态空间搜索策略，每次迭代都会增加深度限制直到d(d为深度最浅的可行解对应的深度)。IDDFS等同于广度优先搜索，但是它需要更少的内存开销。每次迭代它会以深度优先搜索的顺序来访问节点，但是总体的累积效果还是广度优先搜索的。</译>

        好了，有点乱哈，一下BFS一下DFS的。咱还是不翻译了，这么说吧，我们可以把一次深度优先搜索看做一个深度为n的搜索单元，这个搜索单元是基于上级的广度优先搜索的。然后该深度n会在每次迭代是不断加深，直到找到可行解为止。因为深度优先是不存储"备选节点“的，于是整个IDDFS的内存开销不大，又因为搜索的上层控制是广度优先搜索，于是整个IDDFS等同于广度优先搜索。IDDFS集合了DFS和BFS两者的优点，其空间复杂度是O(bd),时间复杂度是O(b^d)。感兴趣的朋友可以查看笔者的另一篇文章：IDDFS(Iterative deepening depth-first search)的Java实现

        现在来说一下IDA*，设想有这样的一个场景，有老板A和员工B，老板A有一个拼图游戏需要求解，老板观察了一下问题，根据问题的manhattan距离得到了一个可能的最小步骤解n。于是把员工B叫过来，说你给我在n步之内解出题目。于是员工B开始解题，他的方法很简单采用深搜的方法搜索所有符合该manhattan距离限制的解，此时，可能当员工B遍历了所以的结果后还是没有找到可行解，于是他只能把这个结果和老板A说了，老板A看了以后，允许解题步骤限制+1，然后员工B在以这个n+1的步骤限制，从头开始做一个遍历，可能他还没有找到可行解，他就会再去找老板，老板说再加1吧，如此循环，直到员工B求得可行解。

实现代码：

package com.wly.algorithmbase.search;

/**
 * IDA*求解15puzzle问题
 * IDA*整合了IDDFS和A*算法。其中IDDFS控制了求解过程中的内存开销，A*算法意味着"启发式"搜索。
 * IDA*可以理解成迭代深度的A*算法，其中这里的"深度"指的是问题的解的"假定损耗"。
 * 使"假定损耗"不断迭代增加，检验是否能在"假定损耗"的前提找到可行解，如果不行的话，就继续迭代。
 * 这里和A*算法不同的是没有开放列表，由于采用了IDDFS的策略，IDA*是深度优先搜索的，故此没有开放列表。
 * @author wly
 * @date 2013-12-20
 *
 */
public class IDAStarAlgorithm {

	//分别代表左、上、右、下四个移动方向的操作数
	private int[] up = {-1,0};
	private int[] down = {1,0};
	private int[] left = {0,-1};
	private int[] right = {0,1};
	
	/**注意，这里UP和DOWN，LEFT和RIGHT必须是两两相对的，因为后面代码中使用
	 * ((dPrev != dCurr) && (dPrev%2 == dCurr%2))
	 * 来判断前后两个移动方向是否相反
	 */
	private final int UP = 0;
	private final int DOWN = 2;
	private final int LEFT = 1;
	private final int RIGHT = 3;
	
	private int SIZE;
	
	//各个目标点坐标
	private int[][] targetPoints; 
	
	//用于记录移动步骤，存储0,1,2,3,对应上，下，左，右
	private static int[] moves = new int[100000];
	
	private static long ans = 0;; //当前迭代的"设想代价"
	
	//目标状态
	private static int[][] tState = {
		{1 ,2 ,3 ,4 } ,
		{5 ,6 ,7 ,8 } ,
		{9 ,10,11,12} ,
		{13,14,15,0 }
	};
	
	private static int[][] sState = {
		{2 ,10 ,3 ,4 } ,
		{1 ,0,6 ,8 } ,
		{5 ,14,7,11} ,
		{9,13,15,12 }
	};
	
	//初始状态
//	private static int[][] sState = {
//		{12,1 ,10,2 } ,
//		{7 ,11,4 ,14} ,
//		{5 ,0 ,9 ,15} ,
//		{8 ,13,6 ,3} 
//	};
	
	private static int blank_row,blank_column;
	
	public IDAStarAlgorithm(int[][] state) {
		SIZE = state.length;
		targetPoints = new int[SIZE * SIZE][2];
		
		this.sState = state;
		//得到空格坐标
		for(int i=0;i<state.length;i++) {
			for(int j=0;j<state[i].length;j++) {
				if(state[i][j] == 0) {
					blank_row = i;
					blank_column = j;
					break;
				}
			}
		}
		
		//得到目标点坐标数组
		for(int i=0;i<state.length;i++) {
			for(int j=0;j<state.length;j++) {
				targetPoints[tState[i][j]][0] = i; //行信息
				
				targetPoints[tState[i][j]][1] = j; //列信息
			}
		}
	}
	
	/**
	 * 讨论问题的可解性
	 * @param state 状态
	 */
	private boolean canSolve(int[][] state) {
		if(state.length % 2 == 1) { //问题宽度为奇数
			return (getInversions(state) % 2 == 0);
		} else { //问题宽度为偶数
			if((state.length - blank_row) % 2 == 1) { //从底往上数,空格位于奇数行
				return (getInversions(state) % 2 == 0);
			} else { //从底往上数,空位位于偶数行
				return (getInversions(state) % 2 == 1);
			}
		}
	}
	
	public static void main(String[] args) {
		
		IDAStarAlgorithm idaAlgorithm = new IDAStarAlgorithm(sState);
		if(idaAlgorithm.canSolve(sState)) {
			System.out.println("--问题可解，开始求解--");
			//以曼哈顿距离为初始最小代价数
			int j = idaAlgorithm.getHeuristic(sState);
			System.out.println("初始manhattan距离:" + j);
			int i = -1;//置空默认移动方向
			
			long time = System.currentTimeMillis();
			//迭代加深"最小代价数"
			for(ans=j;;ans++) {
				if(idaAlgorithm.solve(sState
						,blank_row,blank_column,0,i,j)) {
					break;
				}
			}
			System.out.println("求解用时:"+(System.currentTimeMillis() - time));

			idaAlgorithm.printMatrix(sState);
			int[][] matrix = idaAlgorithm.move(sState,moves[0]);
			for(int k=1;k<ans;k++) {
				matrix = idaAlgorithm.move(matrix, moves[k]);
			}
			
		} else {
			System.out.println("--抱歉！输入的问题无可行解--");
		}
	}
	
	public int[][] move(int[][]state,int direction) {
		int row = 0;
		int column = 0;
		for(int i=0;i<state.length;i++) {
			for(int j=0;j<state.length;j++) {
				if(state[i][j] == 0) {
					row = i;
					column = j;
				}
			}
		}
		switch(direction) {
		case UP:
			state[row][column] = state[row-1][column];
			state[row-1][column] = 0;
			break;
		case DOWN:
			state[row][column] = state[row+1][column];
			state[row+1][column] = 0;
			break;
		case LEFT:
			state[row][column] = state[row][column-1];
			state[row][column-1] = 0;
			break;
		case RIGHT:
			state[row][column] = state[row][column+1];
			state[row][column+1] = 0;
			break;
		}
		printMatrix(state);
		return state;
	}
	
	public void printMatrix(int[][] matrix) {
		System.out.println("------------");
		for(int i=0;i<matrix.length;i++) {
			for(int j=0;j<matrix.length;j++) {
				System.out.print(matrix[i][j] + " ");
			}
			System.out.println();
		}
	}
	
	/**
	 * 求解方法
	 * @param state 当前状态
	 * @param blank_row 空位的行坐标
	 * @param blank_column 空格的列坐标
	 * @param dep 当前深度
	 * @param d 上一次移动的方向
	 * @param h 当前状态估价函数
	 * @return
	 */
	public boolean solve(int[][] state,int blank_row,int blank_column,
			int dep,long d,long h) {
		
		long h1;
		
		//和目标矩阵比较，看是否相同，如果相同则表示问题已解
		boolean isSolved = true;
		for(int i=0;i<SIZE;i++) {
			for(int j=0;j<SIZE;j++) {
				if(state[i][j] != tState[i][j]) {
					isSolved = false;
				}
			}
		}
		if(isSolved) {
			return true;
		}
		
		if(dep == ans) {
			return false;
		}

		//用于表示"空格"移动后的坐标位置
		int blank_row1 = blank_row;
		int blank_column1  = blank_column;
		int[][] state2 = new int[SIZE][SIZE];

		for(int direction=0;direction<4;direction++) {
			for(int i=0;i<state.length;i++) {
				for(int j=0;j<state.length;j++) {
					state2[i][j] = state[i][j];
				}
			}
			
			//本地移动方向和上次移动方向刚好相反，跳过这种情况的讨论
			if(direction != d && (d%2 == direction%2)) {
				continue;
			}
			
			if(direction == UP) {
				blank_row1 = blank_row + up[0];
				blank_column1 = blank_column + up[1];
			} else if(direction == DOWN) {
				blank_row1 = blank_row + down[0];
				blank_column1 = blank_column + down[1];
			} else if(direction == LEFT) {
				blank_row1 = blank_row + left[0];
				blank_column1 = blank_column + left[1];
			} else {
				blank_row1 = blank_row + right[0];
				blank_column1 = blank_column + right[1];
			}
			
			//边界检查
			if(blank_column1 < 0 || blank_column1 == SIZE
					|| blank_row1 < 0 || blank_row1 == SIZE) {
				continue ;
			}
			
			//交换空格位置和当前移动位置对应的单元格	
			state2[blank_row][blank_column] = state2[blank_row1][blank_column1];
			state2[blank_row1][blank_column1] = 0;
			
			//查看当前空格是否正在靠近目标点
			if(direction == DOWN && blank_row1 
					> targetPoints[state[blank_row1][blank_column1]][0]) {
				h1 = h - 1;
			} else if(direction == UP && blank_row1 
					< targetPoints[state[blank_row1][blank_column1]][0]){
				h1 = h - 1;
			} else if(direction == RIGHT && blank_column1 
					> targetPoints[state[blank_row1][blank_column1]][1]) {
				h1 = h - 1;
			} else if(direction == LEFT && blank_column1 
					< targetPoints[state[blank_row1][blank_column1]][1]) {
				h1 = h - 1;
			} else { 
				//这种情况发生在任意可能的移动方向都会使得估价函数值变大
				h1 = h + 1;
			}
			
			if(h1+dep+1>ans) { //剪枝
				continue;
			}
			
			moves[dep] = direction;
			
			//迭代深度求解
			if(solve(state2, blank_row1, blank_column1, dep+1, direction, h1)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 得到估价函数值
	 */
	public int getHeuristic(int[][] state) {
		int heuristic = 0;
		for(int i=0;i<state.length;i++) {
			for(int j=0;j<state[i].length;j++) {
				if(state[i][j] != 0) {
					heuristic = heuristic + 
							Math.abs(targetPoints[state[i][j]][0] - i)
							+ Math.abs(targetPoints[state[i][j]][1] - j);
					
				}
			}
		}
		return heuristic;
	}
	
	/**
	 * 计算问题的"倒置变量和"
	 * @param state
	 */
	private int getInversions(int[][] state) {
		int inversion = 0;
		int temp = 0;
		for(int i=0;i<state.length;i++) {
			for(int j=0;j<state[i].length;j++) {
				int index = i* state.length + j + 1;
				while(index < (state.length * state.length)) {
					if(state[index/state.length][index%state.length] != 0 
							&& state[index/state.length]
									[index%state.length] < state[i][j]) {
						temp ++;
					}
					index ++;
				}
				inversion = temp + inversion;
				temp = 0;
			}
		}
		return inversion;
	}
}

运行结果：

--问题可解，开始求解--
初始manhattan距离:12
求解用时:0
------------
2 10 3 4 
1 0 6 8 
5 14 7 11 
9 13 15 12 
------------
2 0 3 4 
1 10 6 8 
5 14 7 11 
9 13 15 12 
------------
0 2 3 4 
1 10 6 8 
5 14 7 11 
9 13 15 12 
------------
1 2 3 4 
0 10 6 8 
5 14 7 11 
9 13 15 12 
------------
1 2 3 4 
5 10 6 8 
0 14 7 11 
9 13 15 12 
------------
1 2 3 4 
5 10 6 8 
9 14 7 11 
0 13 15 12 
------------
1 2 3 4 
5 10 6 8 
9 14 7 11 
13 0 15 12 
------------
1 2 3 4 
5 10 6 8 
9 0 7 11 
13 14 15 12 
------------
1 2 3 4 
5 0 6 8 
9 10 7 11 
13 14 15 12 
------------
1 2 3 4 
5 6 0 8 
9 10 7 11 
13 14 15 12 
------------
1 2 3 4 
5 6 7 8 
9 10 0 11 
13 14 15 12 
------------
1 2 3 4 
5 6 7 8 
9 10 11 0 
13 14 15 12 
------------
1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 0 

      O啦~~~

      转载请保留出处:http://blog.csdn.net/u011638883/article/details/17287721

      谢谢!!

 

参考文档：

http://en.wikipedia.org/wiki/IDA*

http://heuristicswiki.wikispaces.com/IDA*