MyFirstgame 拼图

 package auto;

 /**
  * 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} ,
         {16,17,18,19,20},
         {21,22,23,24,0}
     };

     private static int[][] sState = {
         {1,2,3,4,5},
         {6,7,8,9,0},
         {10,11,12,13,14},
         {15,16,17,18,19},
         {20,21,22,23,24}
     };

     //初始状态
 //    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; //列信息
             }
         }
         for(int i=0;i<moves.length;i++) {
             moves[i] = -1;
         }
     }

     /**
      * 讨论问题的可解性
      * @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[] getSolvePath(int[][] data) {
         for(int i=0;i<moves.length;i++) {
             moves[i] = -1;
         }
         if(canSolve(data)) {
             System.out.println("--问题可解，开始求解--");
             //以曼哈顿距离为初始最小代价数
             int j = getHeuristic(data);
             System.out.println("初始manhattan距离:" + j);
             int i = -1;//置空默认移动方向

             long time = System.currentTimeMillis();
             //迭代加深"最小代价数"
             for(ans=j;;ans++) {
                 if(solve(data
                         ,blank_row,blank_column,0,i,j)) {
                     break;
                 }
             }
             System.out.println("求解用时:"+(System.currentTimeMillis() - time));

 //            printMatrix(data);
 //            int[][] matrix = move(data,moves[0]);
 //            for(int k=1;k<ans;k++) {
 //                matrix = move(matrix, moves[k]);
 //            }
             return moves;
         } else {
             System.out.println("--抱歉！输入的问题无可行解--");
             return null;
         }
     }

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

 }

 package auto;

 import java.awt.BorderLayout;
 import java.awt.EventQueue;

 import javax.swing.ImageIcon;
 import javax.swing.JFrame;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.border.EmptyBorder;

 import java.awt.GridLayout;

 import javax.swing.JLabel;

 import java.awt.GridBagLayout;
 import java.awt.GridBagConstraints;
 import java.awt.Insets;
 import java.awt.Color;

 import javax.swing.JButton;

 import java.awt.event.ActionListener;
 import java.awt.event.ActionEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
 import java.util.Stack;

 public class playGame extends JFrame {

     private JPanel contentPane;
 /*    private static JLabel p1;
     private static JLabel p2;
     private static JLabel p3;
     private static JLabel p4;
     private static JLabel p5;
     private static JLabel p6;
     private static JLabel p7;
     private static JLabel p8;
     private static JLabel p9;
 */
     private final int UP = 0;
     private final int DOWN = 2;
     private final int LEFT = 1;
     private final int RIGHT = 3;
     static JLabel[] p=new JLabel[10];
     static JLabel[][] pa;
     private int start=0;
     static int now;
     private static String[] na;
     private static String[] ni;
     static String[] nn;
     static HashSet<String> s;
     //static String ans="123456789";
     static int rear;
     static int[] a;
     static final int size=3;
     static int [][] state;
     static int [][] tstate;
     static int[] moves=new int[100010];
     static int ans;
     public static int blank_row,blank_column;
     public static playGame frame ;
     /**
      * Launch the application.
      */
     public static void main(String[] args) {
         EventQueue.invokeLater(new Runnable() {
             public void run() {
                 try {
                     frame = new playGame();
                     frame.setVisible(true);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         });
     }

     /**
      * Create the frame.
      */
     public playGame() {
         setForeground(Color.CYAN);
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setBounds(0, 0, 450, 300);
         setSize(600,530);
         contentPane = new JPanel();
         contentPane.setBackground(Color.WHITE);
         contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
         setContentPane(contentPane);
         GridBagLayout gbl_contentPane = new GridBagLayout();
         gbl_contentPane.columnWidths = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         gbl_contentPane.rowHeights = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0};
         gbl_contentPane.columnWeights = new double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE};
         gbl_contentPane.rowWeights = new double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE};
         contentPane.setLayout(gbl_contentPane);

         p[1] = new JLabel("\u56FE\u7247");
         p[1].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(1)){
                     swap(p[1],p[now]);
                     swap(1,now);
                     now=1;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }

         });
         GridBagConstraints gbc_p1 = new GridBagConstraints();
         gbc_p1.gridwidth = 2;
         gbc_p1.gridheight = 2;
         gbc_p1.insets = new Insets(0, 0, 5, 5);
         gbc_p1.gridx = 1;
         gbc_p1.gridy = 1;
         contentPane.add(p[1], gbc_p1);

         p[2] = new JLabel("\u56FE\u7247");
         p[2].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(2)){
                     swap(p[2],p[now]);
                     swap(2,now);
                     now=2;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p2 = new GridBagConstraints();
         gbc_p2.gridheight = 2;
         gbc_p2.anchor = GridBagConstraints.NORTHWEST;
         gbc_p2.gridwidth = 2;
         gbc_p2.insets = new Insets(0, 0, 5, 5);
         gbc_p2.gridx = 3;
         gbc_p2.gridy = 1;
         contentPane.add(p[2], gbc_p2);

         p[3] = new JLabel("\u56FE\u7247");
         p[3].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(3)){
                     swap(p[3],p[now]);
                     swap(3,now);
                     now=3;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p3 = new GridBagConstraints();
         gbc_p3.gridheight = 2;
         gbc_p3.gridwidth = 2;
         gbc_p3.insets = new Insets(0, 0, 5, 5);
         gbc_p3.gridx = 5;
         gbc_p3.gridy = 1;
         contentPane.add(p[3], gbc_p3);

         JButton last = new JButton("\u4E0A\u4E00\u5F20");
         last.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 if(start<0)
                     start=start+3;
                 init(start);
             }
         });
         GridBagConstraints gbc_last = new GridBagConstraints();
         gbc_last.insets = new Insets(0, 0, 5, 0);
         gbc_last.gridx = 11;
         gbc_last.gridy = 1;
         contentPane.add(last, gbc_last);

         p[4] = new JLabel("\u56FE\u7247");
         p[4].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(4)){
                     swap(p[4],p[now]);
                     swap(4,now);
                     now=4;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p4 = new GridBagConstraints();
         gbc_p4.gridwidth = 2;
         gbc_p4.gridheight = 2;
         gbc_p4.insets = new Insets(0, 0, 5, 5);
         gbc_p4.gridx = 1;
         gbc_p4.gridy = 3;
         contentPane.add(p[4], gbc_p4);

         p[5] = new JLabel("\u56FE\u7247");
         p[5].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(5)){
                     swap(p[5],p[now]);
                     swap(5,now);
                     now=5;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p5 = new GridBagConstraints();
         gbc_p5.gridwidth = 2;
         gbc_p5.gridheight = 2;
         gbc_p5.insets = new Insets(0, 0, 5, 5);
         gbc_p5.gridx = 3;
         gbc_p5.gridy = 3;
         contentPane.add(p[5], gbc_p5);

         p[6] = new JLabel("\u56FE\u7247");
         p[6].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(6)){
                     swap(p[6],p[now]);
                     swap(6,now);
                     now=6;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p6 = new GridBagConstraints();
         gbc_p6.gridwidth = 2;
         gbc_p6.gridheight = 2;
         gbc_p6.insets = new Insets(0, 0, 5, 5);
         gbc_p6.gridx = 5;
         gbc_p6.gridy = 3;
         contentPane.add(p[6], gbc_p6);

         JButton next = new JButton("\u4E0B\u4E00\u5F20");
         next.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 start++;
                 if(start>=3)
                     start-=3;
                 init(start);
             }
         });
         GridBagConstraints gbc_next = new GridBagConstraints();
         gbc_next.insets = new Insets(0, 0, 5, 0);
         gbc_next.gridx = 11;
         gbc_next.gridy = 3;
         contentPane.add(next, gbc_next);

         p[7] = new JLabel("\u56FE\u7247");
         p[7].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(7)){
                     swap(p[7],p[now]);
                     swap(7,now);
                     now=7;
                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p7 = new GridBagConstraints();
         gbc_p7.gridwidth = 2;
         gbc_p7.gridheight = 2;
         gbc_p7.insets = new Insets(0, 0, 5, 5);
         gbc_p7.gridx = 1;
         gbc_p7.gridy = 5;
         contentPane.add(p[7], gbc_p7);

         p[8] = new JLabel("\u56FE\u7247");
         p[8].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(8)){
                     swap(p[8],p[now]);
                     swap(8,now);
                     now=8;
                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p8 = new GridBagConstraints();
         gbc_p8.gridwidth = 2;
         gbc_p8.gridheight = 2;
         gbc_p8.insets = new Insets(0, 0, 5, 5);
         gbc_p8.gridx = 3;
         gbc_p8.gridy = 5;
         contentPane.add(p[8], gbc_p8);

         p[9] = new JLabel("\u56FE\u7247");
         p[9].addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
                 if(canswap(9)){
                     swap(p[9],p[now]);
                     swap(9,now);
                     now=9;

                     if(iscorrect()){
                         p[now].setVisible(true);
                         JOptionPane.showMessageDialog(null, "恭喜拼图成功");
                     }
                 }
             }
         });
         GridBagConstraints gbc_p9 = new GridBagConstraints();
         gbc_p9.gridwidth = 2;
         gbc_p9.gridheight = 2;
         gbc_p9.insets = new Insets(0, 0, 5, 5);
         gbc_p9.gridx = 5;
         gbc_p9.gridy = 5;
         contentPane.add(p[9], gbc_p9);

         JButton auto = new JButton("\u81EA\u52A8\u6F14\u793A");
         auto.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 pa=new JLabel[3][3];
                 for(int i=0;i<3;i++){
                     for(int j=0;j<3;j++){
                         pa[i][j]=p[i*3+j+1];
                     }
                 }
                 gettstate();
                 AutoRunner au=new AutoRunner(tstate);
                 if(au.canSolve(tstate)){
                     System.out.println("--问题可解，开始求解--");
                     //以曼哈顿距离为初始最小代价数
                     int j = au.getHeuristic(tstate);
                     System.out.println("初始manhattan距离:" + j);
                     int i = -1;//置空默认移动方向

                     long time = System.currentTimeMillis();
                     //迭代加深"最小代价数"
                     for(au.ans=j;;au.ans++) {
                         if(au.solve(tstate
                                 ,blank_row,blank_column,0,i,j)) {
                             break;
                         }
                     }
                     moves=au.getmoves();

                     JOptionPane.showMessageDialog(null,"求解用时:"+(System.currentTimeMillis() - time)/1000.0);

                     //JOptionPane.showMessageDialog(null, "第"+(0)+"步！");
                     for(int k=0;k<au.ans;k++){
                         tstate=move(tstate,moves[k]);
                         for(i=0;i<tstate.length;i++){
                             for(j=0;j<tstate[i].length;j++){
                                 if(tstate[i][j]==0){
                                     pa[i][j].setVisible(false);
                                 }
                                 else{
                                     pa[i][j].setVisible(true);
                                 }
                             }
                         }

                         JOptionPane.showMessageDialog(null, "第"+(k+1)+"步！");
                         try{
                             Thread thread = Thread.currentThread();
                             thread.sleep(1000);//暂停1.5秒后程序继续执行
                         }catch (InterruptedException e1) {
                             // TODO Auto-generated catch block
                             e1.printStackTrace();
                         }

                     /*    try {
                             Thread.sleep(1000);
                         } catch (InterruptedException e1) {
                             // TODO Auto-generated catch block
                             e1.printStackTrace();
                         }
                     */
                         print(tstate);
                         }
                     for(i=0;i<3;i++){
                         for(j=0;j<3;j++){
                             pa[i][j].setVisible(true);
                         }

                     }
                     }else {

                         JOptionPane.showMessageDialog(null,"--抱歉！输入的问题无可行解--");
                         for(int i=0;i<3;i++){
                             for(int j=0;j<3;j++){
                                 p[i*3+j+1]=pa[i][j];
                             }
                         }
                         init(start);
                     }

                 for(int i=0;i<3;i++){
                     for(int j=0;j<3;j++){
                         p[i*3+j+1]=pa[i][j];
                     }
                 }
             }
                     /*int[][] matrix = au.move(tstate,moves[0]);
                     for(int k=1;k<au.ans;k++) {
                         matrix = au.move(matrix, moves[k]);
                     }

                 } else {
                     System.out.println("--抱歉！输入的问题无可行解--");
                 }
                 */
         });
         GridBagConstraints gbc_auto = new GridBagConstraints();
         gbc_auto.insets = new Insets(0, 0, 5, 0);
         gbc_auto.gridx = 11;
         gbc_auto.gridy = 5;
         contentPane.add(auto, gbc_auto);

         JButton button = new JButton("\u672C\u5F20");
         button.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 init(start);
             }
         });
         GridBagConstraints gbc_button = new GridBagConstraints();
         gbc_button.gridx = 11;
         gbc_button.gridy = 7;
         contentPane.add(button, gbc_button);
         playGame.init(start);
     }

 /*    public static void show1(int[][] tstate2) {
         // TODO Auto-generated method stub
         for(int i=0;i<tstate2.length;i++){
             for(int j=0;j<tstate2[i].length;j++){
                 if(state[i][j]==0){
                     pa[i][j].setVisible(false);
                 }
                 else{
                     pa[i][j].setVisible(true);
                 }
             }
         }
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 */
     public static void print(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();
         }
     }

     public int[][] move(int[][]state1,int direction) {
         int row = 0;
         int column = 0;
         for(int i=0;i<state1.length;i++) {
             for(int j=0;j<state1.length;j++) {
                 if(state1[i][j] == 0) {
                     row = i;
                     column = j;
                 }
             }
         }
         switch(direction) {
         case UP:
             swap(pa[row-1][column],pa[row][column]);

             state1[row][column] = state1[row-1][column];
             state1[row-1][column] = 0;
             break;
         case DOWN:
             swap(pa[row+1][column],pa[row][column]);

             state1[row][column] = state1[row+1][column];
             state1[row+1][column] = 0;
             break;
         case LEFT:
             swap(pa[row][column-1],pa[row][column]);

             state1[row][column] = state1[row][column-1];
             state1[row][column-1] = 0;
             break;
         case RIGHT:
             swap(pa[row][column+1],pa[row][column]);

             state1[row][column] = state1[row][column+1];
             state1[row][column+1] = 0;
             break;
         }
         return state1;
     }

     public static void gettstate(){
         tstate=new int[size][size];
     //    int t=Integer.parseInt(""+ni[9].charAt(8));
         for(int i=0;i<size;i++){
             for(int j=0;j<size;j++){
                 char a1=ni[i*3+j+1].charAt(8);
                 String s1=""+a1;
                 if(a1=='9'){
                     tstate[i][j]=0;
                     blank_row=i;
                     blank_column=j;
                 }
                 else{
                     tstate[i][j]=Integer.parseInt(s1);
                 }
             }
         }

     }
     private static void init(int s) {
         // TODO Auto-generated method stub
         char a='a';
         a+=s;
         na=new String[15];
         ni=new String[15];
         for(int i=1;i<10;i++){
             na[i]="images/"+a+i+".jpg";
             //System.out.println(na[i]);
         }
         int m[]=new int[10];  //随机产生10个不同的数（1,9）；
         for(int i=1;i<10;i++){
             int n=(int) (Math.random()*1000%9+1);
             while(canputin(m,i,n)==false){
                 n=(int) (Math.random()*1000%9+1);
             }
             m[i]=n;
             System.out.println(n);
             ni[n]=na[i];   //插入方式i是位置，na[n]是图片
             //correct 方法是第一个位置为图片1.。。
         }
         for(int i=1;i<10;i++){
             System.out.println(ni[i]);
         }
         state=new int[size][size];
         for(int i=0;i<size;i++){
             for(int j=0;j<size;j++){
                 char a1=na[i*3+j+1].charAt(8);
                 String s1=""+a1;
                 state[i][j]=Integer.parseInt(s1);
             }
         }
         state[size-1][size-1]=0;
         for(int i=1;i<10;i++)
         {
             p[i].setIcon(new ImageIcon(ni[i]));
             p[i].setText("");

         }

         for(int i=1;i<9;i++){
             p[i].setVisible(true);
         }
         p[9].setVisible(false);
         now=9;

     }

     private static boolean canputin(int[] m, int s, int n) {
         // TODO Auto-generated method stub
         for(int i=1;i<s;i++){
             if(m[i]==n)
                 return false;
         }
         return true;
     }

     //swap中b为setVisible（false）;

     public static void swap(int m,int n){
         String ss=ni[m];
         ni[m]=ni[n];
         ni[n]=ss;
     }
     private static boolean iscorrect(){
         for(int i=1;i<10;i++){
             if(!na[i].equals(ni[i]))
                 return false;
         }
         return true;
     }

     public static boolean canswap(int i){
         if(i+1==now||i-1==now||i+3==now||i-3==now)
             return true;
         return false;
     }

     public static void swap(JLabel a,JLabel b){
         JLabel c=new JLabel();
         c.setIcon(a.getIcon());
         a.setIcon(b.getIcon());
         b.setIcon(c.getIcon());
         a.setVisible(false);
         b.setVisible(true);
     }

     private static boolean correct(String[] nt) {
         // TODO Auto-generated method stub
         for(int i=1;i<10;i++){
             if(!na[i].equals(nt[i])){
                 return false;
             }
         }
         return true;
     }

     private static boolean canplay() {
         // TODO Auto-generated method stub
         for(int i=1;i<10;i++){
             if(!ni[i].equals(na[i]))
                 return false;
         }
         return true;
     }
 }

只想说目前封装的实在是太烂了！