回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。用回溯算法解决问题的一般步骤为：
1、定义一个解空间，它包含问题的解。
2、利用适于搜索的方法组织解空间。
3、 以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。
问题的解空间通常是在搜索问题的解的过程中动态产生的，这是回溯算法的一个重要特性。
基本思想：回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该(死)结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索
n皇后问题回溯法求解：
public class Queen {
int QUEEN_COUNT = 8; //随便你定义几个皇后了，你可以循环产生a个到b个皇后的解
static final int EMPTY = 0; //如果count[x][y] == EMPTY ,则可以放置皇后；反之，其正上方或斜上方必己放置皇后
int[][] count = new int[QUEEN_COUNT][QUEEN_COUNT]; //
int[] QueenIndex = new int[QUEEN_COUNT]; //第index行的皇后放置位置是QueenIndex [index]
int resultCount = 0; //记录皇后放置方法的数量
public void putQueenIndex(int index) {
int row = index;
for (int col = 0; col < QUEEN_COUNT; col++) {
if (count[row][col] == EMPTY) { //该位置可以放置皇后
for (int iRow = row+ 1; iRow < QUEEN_COUNT; iRow++) { //增加该位置的正下面/斜下面的count，使之不为0
count[iRow][col]++;
if ((col - iRow + row) >= 0) {
count[iRow][col - iRow + row]++;
}
if ((col + iRow - row) < QUEEN_COUNT) {
count[iRow][col + iRow - row]++;
}
}
QueenIndex[row] = col;
if (row == QUEEN_COUNT - 1) { //第QUEEN_COUNT个皇后己放置好，打印出这种皇后布局
print(++resultCount);
} else { //继续放置下一行的皇后
putQueenIndex(row + 1);
}
for (int iRow = row+ 1; iRow < QUEEN_COUNT; iRow++) { //回溯，在此行的皇后不放此列col ，恢复该位置的正下面/斜下面的count
count[iRow][col]--;
if ((col - iRow + row) >= 0) {
count[iRow][col - iRow + row]--;
}
if ((col + iRow - row) < QUEEN_COUNT) {
count[iRow][col + iRow - row]--;
}
}
}
}
if (row == 0) {
System.out.println(QUEEN_COUNT + "皇后共有 " + resultCount + " 个解");
}
}
public void print(int n) { //打印皇后布局
System.out.println(QUEEN_COUNT + "皇后的第 " + n + " 个解：");
for (int i = 0; i < QUEEN_COUNT; i++) {
for (int j = 0; j < QUEEN_COUNT; j++) {
System.out.print(QueenIndex[i] == j ? " * " : " - ");
}
System.out.println();
}
System.out.println();
}
public static void main(String[] args) {
new Queen().putQueenIndex(0);
}
}代码运行结果：
回溯法求解的一般模式（n皇后）
void Trial(int i,int n){
if(i>n) 输出棋盘的当前布局；//合法布局
else for(j=1;j<=n;++j){
在第i行j列放置一枚棋子；
if（当前布局合法） Trial(i+1,n);
移走第i行j列的棋子；
}
}更普遍的，用递归函数来实现回溯法：
void Backtrack(int t){
if(t>n) Output(x);//搜索到叶节点，输出得到的可行解(t表示递归深度)
else
//f、g分别表示在当前扩展结点处未搜索过的子树的起始编号和终止编号
for(int i=f(n,t);i<=g(n,t);i++){
x[t]=h(i);//h(i)表示在当前扩展结点处x[t]的第i个可选值
if(Constraint(t)&&Bound(t)) Backtrack(n+1);
//Constraint(t)和Bound(t)分别表示当前扩展结点处的约束函数和限界函数，不满足条件时，须剪枝
}
}
