算法02-回溯算法
1.回溯算法-八皇后
/**
* row and col not cat save more queen
*/
public class EightQueen {
private final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
public void calculate(int queen, int y, int[] checkerboard) {
if (queen == y)
threadLocal.set(threadLocal.get() + 1);
else {
for (int i = 0;i < queen;i++) {
// find can save queen place
if (checkerboard[i] == 0) {
checkerboard[i] = 1;
calculate(queen, y + 1, checkerboard);
// back track and find next can save queen place
// if(i==queen) again back track
checkerboard[i] = 0;
}
}
}
}
/**
* queen=1 1
* queen=2 queen=1*2=2
* queen=3 queen(2)=2*3-6
* queen=4 queen(3)=6*4=24
* @param queen
* @return
*/
public int simpleCalculate(int queen) {
if (queen == 1)
return 1;
return simpleCalculate(queen - 1) * queen;
}
public int calculate(int queen) {
threadLocal.set(0);
calculate(queen, 0, new int[queen]);
return threadLocal.get();
}
public static void main(String[] args) {
EightQueen queen = new EightQueen();
// queen size
int queenSize = 4;
//System.out.println(queen.calculate(queenSize));
System.out.println(queen.simpleCalculate(queenSize));
}
}
2.回溯算法-马踏棋盘
/**
* 0 left top
* 1 right top
* 2 right bottom
* 3 left bottom
*/
public class HorseRidingChessboard {
private static final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
private final int[] arrX = {-1, 1, 1, -1};
private final int[] arrY = {-1, -1, 1 ,1};
public boolean horseCanGo(int chessboardSize, int x, int y, int[][] chessboard) {
if (x < 0 || y < 0)
return false;
if (x >= chessboardSize || y >= chessboardSize)
return false;
// not can go place that use 1 mark
return chessboard[x][y] == 0;
}
public void calculateHorseRoute(int chessboardSize, int x, int y, int[][] chessboard) {
if (x == chessboardSize - 1 && y == chessboardSize - 1)
// horse reaches the end
threadLocal.set(threadLocal.get() + 1);
else {
// traverse four direction
for (int i = 0;i < 4;i++) {
x += arrX[i];
y += arrY[i];
if (horseCanGo(chessboardSize, x, y, chessboard)) {
// can go and mark
chessboard[x][y] = 1;
calculateHorseRoute(chessboardSize, x, y, chessboard);
// revoke mark
chessboard[x][y] = 0;
}
// back tracking
x -= arrX[i];
y -= arrY[i];
}
}
}
public int calculateHorseRoute(int chessboardSize) {
threadLocal.set(0);
int[][] chessboard = new int[chessboardSize][chessboardSize];
// init chessboard, avoid horse again go {0,0}
chessboard[0][0] = 1;
calculateHorseRoute(chessboardSize, 0, 0, chessboard);
return threadLocal.get();
}
public static void main(String[] args) {
// chessboard size
final int chessboardSize = 4;
HorseRidingChessboard horseRidingChessboard = new HorseRidingChessboard();
int result = horseRidingChessboard.calculateHorseRoute(chessboardSize);
System.out.println(result);
}
}