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;
}
}
只想说目前封装的实在是太烂了！