回溯法有“通用解題法”之稱。用它可以系統地搜尋問題的所有解。回溯法是一個既帶有系統性又帶有跳躍性的搜尋演算法。

    在包含問題的所有解的解空間樹中，按照深度優先搜尋的策略，從根結點出發深度探索解空間樹。當探索到某一結點時，要先判斷該結點是否包含問題的解，如果包含，就從該結點出發繼續探索下去，如果該結點不包含問題的解，則逐層向其祖先結點回溯。（其實回溯法就是對隱式圖的深度優先搜尋演算法）。若用回溯法求問題的所有解時，要回溯到根，且根結點的所有可行的子樹都要已被搜尋遍才結束。 而若使用回溯法求任一個解時，只要搜尋到問題的一個解就可以結束。

1.回溯法的解題步驟

(1)針對所給問題，定義問題的解空間；

(2)確定易於搜尋的解空間結構；

(3)以深度優先方式搜尋解空間，並在搜尋過程中用剪枝函式避免無效搜尋。

2.子集樹與排列樹

下面的兩棵解空間樹是回溯法解題時常遇到的兩類典型的解空間樹。

(1)當所給問題是從n個元素的集合S中找出S滿足某種性質的子集時，相應的解空間樹稱為子集樹。例如從n個物品的0-1揹包問題(如下圖)所相應的解空間樹是一棵子集樹，這類子集樹通常有2^n個葉結點，其結點總個數為2^(n+1)-1。遍歷子集樹的演算法需Ω(2^n)計算時間。

(2)當所給問題是確定n個元素滿足某種性質的排列時，相應的解空間樹稱為排列樹。例如旅行售貨員問題(如下圖)的解空間樹是一棵排列樹，這類排列樹通常有n!個葉結點。遍歷子集樹的演算法需Ω(n!)計算時間。

用回溯法搜尋子集樹的一般演算法可描述為：

	/**
	 * output(x)     記錄或輸出得到的可行解x
	 * constraint(t) 當前結點的約束函式
	 * bount(t)      當前結點的限界函式
	 * @param t  t為當前解空間的層數
	 */
	void backtrack(int t){
		if(t >= n)
			output(x);
		else
			for (int i = 0; i <= 1; i++) {
				x[t] = i;
				if(constraint(t) && bount(t))
					backtrack(t+1);
			}
	}
 

	/**
	 * output(x)     記錄或輸出得到的可行解x
	 * constraint(t) 當前結點的約束函式
	 * bount(t)      當前結點的限界函式
	 * @param t  t為當前解空間的層數
	 */
	void backtrack(int t){
		if(t >= n)
			output(x);
		else
			for (int i = t; i <= n; i++) {
				swap(x[t], x[i]);
				if(constraint(t) && bount(t))
					backtrack(t+1);
				swap(x[t], x[i]);
			}
	}

3.回溯法的應用例子

(a)子集樹

（為了便於描述演算法，下列方法使用了較多的全域性變數）

I.輸出集合S中所有的子集，即limit為all；

II.輸出集合S中限定元素數量的子集，即limit為num；

III.輸出集合S中元素奇偶性相同的子集，即limit為sp。

public class Subset {
		
	private static int[] s = {1,2,3,4,5,6,7,8};
	private static int n = s.length;
	private static int[] x = new int[n];
	
	/**
	 * 輸出集合的子集
	 * @param limit  決定選出特定條件的子集
	 * 注：all為所有子集,num為限定元素數量的子集,
	 *    sp為限定元素奇偶性相同，且和小於8。
	 */
	public static void all_subset(String limit){
		switch(limit){
		case "all":backtrack(0);break;
		case "num":backtrack1(0);break;
		case "sp":backtrack2(0);break;
		}
	}
	

	/**
	 * 回溯法求集合的所有子集，依次遞迴
	 * 注：是否回溯的條件為精髓
	 * @param t
	 */
	private static void backtrack(int t){
		if(t >= n)
			output(x);
		else
			for (int i = 0; i <= 1; i++) {
				x[t] = i;
				backtrack(t+1);
			}
		
	}
	
	/**
	 * 回溯法求集合的所有(元素個數小於4)的子集，依次遞迴
	 * @param t
	 */
	private static void backtrack1(int t){
		if(t >= n)
			output(x);
		else
			for (int i = 0; i <= 1; i++) {
				x[t] = i;
				if(count(x, t) < 4)
					backtrack1(t+1);
			}
		
	}

	/**
	 * (剪枝)
	 * 限制條件：子集元素小於4,判斷0~t之間已被選中的元素個數，
	 *        因為此時t之後的元素還未被遞迴,即決定之後的元素
	 *        是否應該被遞迴呼叫
	 * @param x
	 * @param t
	 * @return
	 */
	private static int count(int[] x, int t) {
		int num = 0;
		for (int i = 0; i <= t; i++) {
			if(x[i] == 1){
				num++;
			}
		}
		return num;
	}

	/**
	 * 回溯法求集合中元素奇偶性相同，且和小於8的子集,依次遞迴
	 * @param t
	 */
	private static void backtrack2(int t){
		if(t >= n)
			output(x);
		else
			for (int i = 0; i <= 1; i++) {
				x[t] = i;
				if(legal(x, t))
					backtrack2(t+1);
			}
		
	}
	
	/**
	 * 對子集中元素奇偶性進行判斷，還需元素的陣列和小於8
	 * @param x
	 * @param t
	 * @return
	 */
	private static boolean legal(int[] x, int t) {
		boolean bRet = true;   //判斷是否需要剪枝
		int part = 0;  //奇偶性判斷的基準
		
		for (int i = 0; i <= t; i++) {  //選擇第一個元素作為奇偶性判斷的基準
			if(x[i] == 1){
				part = i;
				break;
			}
		}
		
		for (int i = 0; i <= t; i++) {
			if(x[i] == 1){
				bRet &= ((s[part] - s[i]) % 2 == 0);
			}
				
		}

		int sum = 0;
		for(int i = 0; i <= t; i++){
			if(x[i] == 1)
				sum += s[i];
		}
		bRet &= (sum < 8);
		    
		return bRet;
	}


	/**
	 * 子集輸出函式
	 * @param x
	 */
	private static void output(int[] x) {
		for (int i = 0; i < x.length; i++) {
			if(x[i] == 1){
				System.out.print(s[i]);
			}
		}
		System.out.println();	
	}

}

(b) 排列樹

（為了便於描述演算法，下列方法使用了較多的全域性變數）

I.輸出集合S中所有的排列，即limit為all；

II.輸出集合S中元素奇偶性相間的排列，即limit為sp。

public class Permutation {

	private static int[] s = {1,2,3,4,5,6,7,8};
	private static int n = s.length;
	private static int[] x = new int[n];
	
	/**
	 * 輸出集合的排列
	 * @param limit  決定選出特定條件的子集
	 * 注：all為所有排列,sp為限定元素奇偶性相間。
	 */
	public static void all_permutation(String limit){
		switch(limit){
		case "all":backtrack(0);break;
		case "sp":backtrack1(0);break;
		}
	}
	

	/**
	 * 回溯法求集合的所有排列，依次遞迴
	 * 注：是否回溯的條件為精髓
	 * @param t
	 */
	private static void backtrack(int t){
		if(t >= n)
			output(s);
		else
			for (int i = t; i < n; i++) {
				swap(i, t, s);
				backtrack(t+1);
				swap(i, t, s);
			}
		
	}

	/**
	 * 回溯法求集合中元素奇偶性相間的排列,依次遞迴
	 * @param t
	 */
	private static void backtrack1(int t){
		if(t >= n)
			output(s);
		else
			for (int i = t; i < n; i++) {
				swap(i, t, s);
				if(legal(x, t))
					backtrack1(t+1);
				swap(i, t, s);
			}
		
	}
	
	/**
	 * 對子集中元素奇偶性進行判斷
	 * @param x
	 * @param t
	 * @return
	 */
	private static boolean legal(int[] x, int t) {
		boolean bRet = true;   //判斷是否需要剪枝
		
		//奇偶相間,即每隔一個數判斷奇偶相同
		for (int i = 0; i < t - 2; i++) {
			bRet &= ((s[i+2] - s[i]) % 2 == 0);
		}
		    
		return bRet;
	}


	/**
	 * 元素交換
	 * @param i
	 * @param j
	 */
	private static void swap(int i, int j,int[] s) {
		int tmp = s[i];
		s[i] = s[j];
		s[j] = tmp;
	}
	
	/**
	 * 子集輸出函式
	 * @param x
	 */
	private static void output(int[] s) {
		for (int i = 0; i < s.length; i++) {
				System.out.print(s[i]);
		}
		System.out.println();	
	}
}

參考文獻：

1. 《演算法設計與分析》