算法学习之8数码问题

　　这几天都在写人工智能和信息安全作业，没怎么学算法书，不过现在上的课也多多少少在学算法相关的，这次实验，我们人工智能老师就是要求我们解决八数码问题。

首先我们要知道什么是八数码问题:

　　八数码问题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。

8	5	4
3		7
1	2	6

(a) 初始状态

1	2	3
8		4
7	6	5

(b) 目标状态  

要求：请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或 任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。

　　这里我为了简单点用的bfs（宽度优先搜索），首先给出矩阵后为了方便处理(标记是否出现过)转为一维字符串形式，

/**
    * 把存储8数码的矩阵转换为状态字符串
    * @param Matrix 8数码存储矩阵
    * 状态字符串
    */
   private String convertToStrState(int[][] Matrix)
   {
       String string = "";
       for(int i = 0; i < 3; i++)
       {
           for(int j = 0; j < 3; j++)
           {
               string += Matrix[i][j];
           }
       }
       return string;
   }

然后判断由初始矩阵转目标矩阵是否有解，如何判断是否有解我在网上找了下，是判断初始矩阵的状态字符串的逆序数与目标矩阵的状态字符串的逆序数是否同奇或者同偶，如果同是奇数或同是偶数就有解。否者无解。

/**
    * 判断是否可以由初始的8数码状态到目标状态
    * @param startMatrix 初始化8数码的状态矩阵
    * 是否可以求解
    */
   private boolean isCanSolve(int[][] startMatrix)
   {
       
//       System.out.println(countInverseNumber(startMatrix));
//       System.out.println(countInverseNumber(targetMatrix));
       if(countInverseNumber(startMatrix)%2==1&&countInverseNumber(targetMatrix)%2==1)return true;
       else return false;
   }

如果有解，就开始BFS了，首先把初始状态矩阵放入队列中（这里为了处理方便先把矩阵转为状态字符串再放入的队列），然后循环弹出队列，直到队列为空。【每弹出一个矩阵状态字符串，就把这个矩阵的子矩阵状态的状态字符串放入队列中，矩阵的子矩阵状态就是当前矩阵把0与上、下、左、右、四个位置的数(如果有的话)互换后的矩阵。在放子矩阵状态字符串到队列的时候还要先判断下这个矩阵是否重复出现过。】

全部代码吧。

package gh;

import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingDeque;
 
 /**
  * 八数码问题
  * @author ganhang
  *
  */
public class EightPuzzle
{
   private String targetState = "123804765";//目标状态
   private int[][] targetMatrix = {{1,2,3},{8,0,4},{7,6,5}};//目标矩阵
   private Set<String> hashState = new HashSet<String>();//判断状态是否出现
   private int[] dx = {-1,0,1,0};
   private int[] dy = {0,1,0,-1};
   private Map<String, String> path = new HashMap<String, String>();
   private int step = 0;
   public static void main(String[] args) throws IOException, Exception {
        EightPuzzle eightPuzzle = new EightPuzzle();
        int[][] startMatrix = new int[3][3];
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入初始状态：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                startMatrix[i][j] = scanner.nextInt();
            }
        }

        eightPuzzle.searchSolution(startMatrix);

    }
   /**
    * 求状态矩阵除去0后的逆序数
    * @param Matrix 状态矩阵
    * 
    */
   private int countInverseNumber(int[][] Matrix)
   {
       int[] tmpElem = new int[9];
       int size = 0;
       for(int i = 0; i < 3; i++)
       {
           for(int j = 0; j < 3; j++)
           {
               if(Matrix[i][j] != 0)
               {
                   tmpElem[size++] = Matrix[i][j];
               }
           }
       }
       int ans = 0;
       for(int i = 0; i < size; i++)
       {
           for(int j = i+1; j < size; j++)
           {
               if(tmpElem[i] > tmpElem[j])
               {
                   ans++;
               }
           }
       }
       return ans;
   }
    
   /**
    * 判断是否可以由初始的8数码状态到目标状态
    * @param startMatrix 初始化8数码的状态矩阵
    * 是否可以求解
    */
   private boolean isCanSolve(int[][] startMatrix)
   {
       
//       System.out.println(countInverseNumber(startMatrix));
//       System.out.println(countInverseNumber(targetMatrix));
       if(countInverseNumber(startMatrix)%2==1&&countInverseNumber(targetMatrix)%2==1)return true;
       else return false;
   }
    
   /**
    * 把存储8数码的矩阵转换为状态字符串
    * @param Matrix 8数码存储矩阵
    * 状态字符串
    */
   private String convertToStrState(int[][] Matrix)
   {
       String string = "";
       for(int i = 0; i < 3; i++)
       {
           for(int j = 0; j < 3; j++)
           {
               string += Matrix[i][j];
           }
       }
       return string;
   }
   /**
    * 把状态字符串转换为8数码的矩阵
    * @param state 状态字符串
    *8数码矩阵
    */
   private int[][] convertToMatrix(String state)
   {
       int[][] matrix = new int[3][3];
       for(int i = 0; i < state.length(); i++)
       {
           matrix[i/3][i%3] = state.charAt(i) - '0';
       }
       return matrix;
   }
    
   /**
    * 打印路径
    */
   private void printPath()
   {
 
       Stack<String> stack = new Stack<String>();
       String state = targetState; 
       while(state != null)
       {
           stack.push(state);
           state = path.get(state);
           step++;
       }
       System.out.println("
Ok, I find it!
");
       System.out.println("一共使用了" + (step-1) + "步
");
       while(!stack.isEmpty())
       {
           printMatrix(convertToMatrix(stack.pop()));
       }
   }
    
   /**
    * 打印8数码矩阵
    * @param matrix 8数码矩阵
    */
   private void printMatrix(int[][] matrix)
   {
       for(int i = 0; i < 3; i++)
       {
           for(int j = 0; j < 3; j++)
           {
               System.out.print(matrix[i][j] + " ");
           }
           System.out.println("");
       }
       System.out.println("");
   }
    
   /**
    * BFS搜索可行解
    * @param startMatrix 开始的8数码矩阵
    */
   public void searchSolution(int[][] startMatrix)
 {
        if (!isCanSolve(startMatrix)) System.out.println("开始状态到目标状态无解！");
        else {
            Queue<String> queue = new LinkedBlockingDeque<String>();

            queue.add(convertToStrState(startMatrix));// 初始状态放入队列
            hashState.add(convertToStrState(startMatrix));// 标记初始状态存在
            path.put(convertToStrState(startMatrix), null);

            while (!queue.isEmpty())// 队列非空 ，进行BFS
            {
                String curState = queue.poll();
                int[][] curMatrix = convertToMatrix(curState);

                if (curState.equals(targetState))// 找到目标状态
                {
                    break;
                }
                int curx = 0, cury = 0;

                for (int i = 0; i < 3; i++)// 查找 0 的位置
                {
                    for (int j = 0; j < 3; j++) {
                        if (curMatrix[i][j] == 0) {
                            curx = i;
                            cury = j;
                            break;
                        }
                    }
                }

                String newState = "";// 记录新状态
                int[][] newMatrix = new int[3][3];// 记录新状态矩阵
                for (int i = 0; i < 4; i++)// BFS 相邻状态
                {
                    int newx = curx + dx[i];
                    int newy = cury + dy[i];
                    if (newx <= 2 && newx >= 0 && newy <= 2 && newy >= 0)// 状态合法
                    {

                        for (int j = 0; j < 3; j++) {
                            System.arraycopy(curMatrix[j], 0, newMatrix[j], 0,
                                    curMatrix[j].length);
                        }

                        int temp = newMatrix[newx][newy];
                        newMatrix[newx][newy] = newMatrix[curx][cury];
                        newMatrix[curx][cury] = temp;

                        newState = convertToStrState(newMatrix);

                        if (!hashState.contains(newState))// 如果改状态还未到达过
                        {
                            path.put(newState, curState);
                            queue.add(newState);// 把新状态压入队列
                            hashState.add(newState);// 将新状态存入Hash
                        }
                    }
                }
            }
            printPath();// 打印路径
        }
    }
}