【演算法】回溯法四步走
阿新 • • 發佈：2020-03-14
# 回溯法
對於回溯法，網上有很多種解釋，這裡我依照自己的（死宅）觀點做了以下三種通俗易懂的解釋：
- **正經版解釋：**其實人生就像一顆充滿了分支的n叉樹，你的每一個選擇都會使你走向不同的路線，獲得不同的結局。如果能重來，我要選李白~呸！說錯了，如果能重來，我們就能回溯到以前，選擇到最美好的結局。
- **遊戲版解釋：**玩過互動電影遊戲（如 行屍走肉）的都知道，你的每個選擇都會影響遊戲的結局，掌控他人的生死。每次選擇錯誤導致主角或配角死亡，我們是不是回溯讀檔，希望得到一個更好的結局。
> **PS：**克萊曼婷天下無敵！
- **動漫版解釋：**看過主角擁有死亡迴歸（瘋狂暗示486）的都知道，主角的每個選擇都能影響大局，可是486直接能回溯重選，這與我們今天要講的回溯法極其相似。
> **PS：**愛蜜莉雅、雷姆我都要！
## 專業名詞
- **解空間：**即 所有的可能情況
## 概念
> **回溯演算法：**是類似於列舉的搜尋嘗試過程，主要是在搜尋嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就“回溯”返回，嘗試別的路徑。
它是一種選優搜尋法，按選優條件向前搜尋，以達到目標。但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術稱為**回溯法**，而滿足回溯條件的某個狀態的點稱為**“回溯點”**（你也可以理解為**存檔點**）。
上圖為八皇后的解空間樹，**如果當前點不符合要求就退回再走**。
許多複雜的，規模較大的問題都可以使用回溯法，有“通用解題方法”的美稱。
## 基本思想
在包含問題的所有解的解空間樹中，按照**深度優先搜尋**的策略，從根結點出發深度探索解空間樹。
當探索到某一結點時，要先判斷該結點是否包含問題的解：
- 如果**包含**，就從該結點出發繼續探索下去；
- 如果該結點**不包含**問題的解，則逐層向其祖先結點回溯。（其實回溯法就是對隱式圖的深度優先搜尋演算法）
---
**結束條件：**
- 若用回溯法求問題的**所有解**時，要回溯到根，且根結點的所有可行的子樹都要已被搜尋遍才結束。
- 若使用回溯法求**任一個解**時，只要搜尋到問題的一個解就可以結束。
## 網上的一般步驟
雖然我覺得網上的一般步驟太抽象了，但是還是擺在這裡供大家參考吧。。
1. **針對所給問題，確定問題的解空間：**
首先應明確定義問題的解空間，問題的解空間應至少包含問題的一個（最優）解。
2. **確定結點的擴充套件搜尋規則：**
及時確定規則，並不是每個解空間都要走完才能發現是死路的，有時候走到一半就發現不滿足條件了。
3. **以深度優先方式搜尋解空間**，並在搜尋過程中**用剪枝函式避免無效搜尋：**
不滿足條件的路徑及時剪掉（即 剪枝），避免繼續走下去浪費時間。
> **類比：**比如說**削蘋果**，
我們規定：蘋果皮必須不斷，要完整地削完整個蘋果。
那麼，如果我們削到一半蘋果皮斷掉了，我們就可以直接退回去（即 回溯）換個蘋果削了，如果繼續削下去，只會浪費時間。
## 演算法框架
**問題框架：**
設問題的**解**是一個**n維向量(a1,a2,………,an)**，**約束條件**是**ai(i=1,2,3,…..,n)之間**滿足某種條件，記為 **f(ai)**。
### 非遞歸回溯框架
其中，**a[n]**為解空間，**i**為搜尋的深度，框架如下：
```
int a[n],i; //a[n]為解空間，i為深度
初始化陣列 a[];
i = 1;
while (i>0(有路可走) and (未達到目標)) { //還未回溯到頭
if(i > n) { //搜尋到葉結點
搜尋到一個解，輸出；
} else { //處理第 i 個元素
a[i]第一個可能的值；
while(a[i]在不滿足約束條件且在搜尋空間內) {
a[i]下一個可能的值；
}//while
if(a[i]在搜尋空間內) {
標識佔用的資源；
i = i+1; //擴充套件下一個結點
} else {
清理所佔的狀態空間； //回溯
i = i – 1;
}//else
}//else
}//while
```
### 遞歸回溯框架
**回溯法**是對解空間的**深度優先搜尋**，在一般情況下使用**遞迴函式**來實現回溯法比較簡單。
其中，**a[n]**為解空間，**i**為搜尋的深度，框架如下：
```
int a[n]; //a[n]為解空間
BackTrace(int i) { //嘗試函式，i為深度
if(i>n) {
輸出結果;
} else {
for(j = 下界; j <= 上界; j=j+1) { //列舉 i 所有可能的路徑
if(check(j)) { //檢查滿足限界函式和約束條件
a[i] = j;
... //其他操作
BackTrace(i+1);
回溯前的清理工作（如 a[i]置空值等）;
}//if
}//for
}//else
}//BackTrace
```
## 回溯四步走
由於上述網上的步驟太抽象了，所以在這裡我自己總結了回溯四步走：
- **編寫檢測函式：**檢測函式用來檢測此路徑是否滿足題目條件，是否能通過。
> stack;
boolean p[][] = null;
public Maze() {
maze = new int[15][15];
stack = new Stack();
p = new boolean[15][15];
}
/*
* 構造迷宮
*/
public void init() {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入迷宮的行數");
row = scanner.nextInt();
System.out.println("請輸入迷宮的列數");
col = scanner.nextInt();
System.out.println("請輸入" + row + "行" + col + "列的迷宮");
int temp = 0;
for(int i = 0; i < row; ++i) {
for(int j = 0; j < col; ++j) {
temp = scanner.nextInt();
maze[i][j] = temp;
p[i][j] = false;
}
}
}
/*
* 回溯迷宮，檢視是否有出路
*/
public void findPath() {
// 給原始迷宮的周圍加一圈圍牆
int temp[][] = new int[row + 2][col + 2];
for(int i = 0; i < row + 2; ++i) {
for(int j = 0; j < col + 2; ++j) {
temp[0][j] = 1;
temp[row + 1][j] = 1;
temp[i][0] = temp[i][col + 1] = 1;
}
}
// 將原始迷宮複製到新的迷宮中
for(int i = 0; i < row; ++i) {
for(int j = 0; j < col; ++j) {
temp[i + 1][j + 1] = maze[i][j];
}
}
// 從左上角開始按照順時針開始查詢
int i = 1;
int j = 1;
p[i][j] = true;
stack.push(new Position(i, j));
while (!stack.empty() && (!(i == (row) && (j == col)))) {
if ((temp[i][j + 1] == 0) && (p[i][j + 1] == false)) {
p[i][j + 1] = true;
stack.push(new Position(i, j + 1));
j++;
} else if ((temp[i + 1][j] == 0) && (p[i + 1][j] == false)) {
p[i + 1][j] = true;
stack.push(new Position(i + 1, j));
i++;
} else if ((temp[i][j - 1] == 0) && (p[i][j - 1] == false)) {
p[i][j - 1] = true;
stack.push(new Position(i, j - 1));
j--;
} else if ((temp[i - 1][j] == 0) && (p[i - 1][j] == false)) {
p[i - 1][j] = true;
stack.push(new Position(i - 1, j));
i--;
} else {
stack.pop();
if(stack.empty()) {
break;
}
i = stack.peek().row;
j = stack.peek().col;
}
}
Stack newPos = new Stack();
if (stack.empty()) {
System.out.println("沒有路徑");
} else {
System.out.println("有路徑");
System.out.println("路徑如下：");
while (!stack.empty()) {
Position pos = new Position();
pos = stack.pop();
newPos.push(pos);
}
}
/*
* 圖形化輸出路徑
* */
String resault[][]=new String[row+1][col+1];
for(int k=0; k= m || y >= n || !maze[x][y].equals("0")) { // 注意字串要用equals
return;
}
maze[x][y] = "#"; // 走到此節點
if (x == m - 1 && y == n - 1) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
System.out.print(maze[i][j] + " ");
}
System.out.println();
}
System.out.println("--------------------------------------------------------");
}
find(x + 1, y); //下移
find(x - 1, y); //上移
find(x, y + 1); //右移
find(x, y - 1); //左移
maze[x][y] = "0";
}
}
```
**程式執行結果：**
```
--------------------------------------------------------
迷宮如下：
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 1 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
--------------------------------------------------------
# 0 1 0 0 0 1 0
# 0 1 0 0 0 1 0
# 0 1 0 1 1 0 1
# 1 1 1 # # 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# 0 1 0 0 0 1 0
# 0 1 0 0 0 1 0
# 0 1 0 1 1 0 1
# 1 1 1 0 0 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# 0 1 0 0 0 1 0
# # 1 0 0 0 1 0
# # 1 0 1 1 0 1
# 1 1 1 # # 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# 0 1 0 0 0 1 0
# # 1 0 0 0 1 0
# # 1 0 1 1 0 1
# 1 1 1 0 0 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# # 1 0 0 0 1 0
0 # 1 0 0 0 1 0
# # 1 0 1 1 0 1
# 1 1 1 # # 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# # 1 0 0 0 1 0
0 # 1 0 0 0 1 0
# # 1 0 1 1 0 1
# 1 1 1 0 0 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# # 1 0 0 0 1 0
# # 1 0 0 0 1 0
# 0 1 0 1 1 0 1
# 1 1 1 # # 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
# # 1 0 0 0 1 0
# # 1 0 0 0 1 0
# 0 1 0 1 1 0 1
# 1 1 1 0 0 1 0
# # # 1 # # # 0
0 1 # # # 1 # 1
0 1 1 1 1 0 # 1
1 1 0 0 0 1 # 1
1 1 0 0 0 0 # #
--------------------------------------------------------
```
## 馬走日
假設國際象棋棋盤有 5\*5 共 25 個格子。
設計一個程式，使棋子從初始位置（棋盤編號為 1 的位）開始跳馬，能夠把棋盤的格子全部都走一遍，每個格子只允許走一次。
1. 輸出一個如圖 2 的解，左上角為第一步起點。
2. 總共有多少解。
> **PS：**國際象棋的棋子是在格子中間的。國際象棋中的“馬走日”，如下圖所示，第一步為[1,1],
第二步為[2,8]或[2,12]，第三步可以是[3,5]或[3,21]等，以此類推。
---
**答案：**
- 明確函式功能：jump(m, n)為跳到(m, n)位置。
- 尋找遞迴出口：不在邊界之內 或 已走過。
- 明確所有路徑：8個方位，
> **技巧：**這裡可以用一個數組存入八個方位的變化，再用迴圈依次取出，比寫八個方位要聰明許多。
- 回溯還原現場：
path--; // 回溯法關鍵步驟
a[m][n] = 0;
```
//馬走日
class Sy2 {
private static int[][] next = { { 1, 2 }, { 1, -2 }, { -1, 2 }, { -1, -2 }, { 2, 1 }, { 2, -1 }, { -2, 1 }, { -2, -1 } }; // 馬的跳躍路徑（技巧）
private static int[][] map; // 地圖
private static int m, n;
private static int count = 0;// 統計有多少種走法
private static int step = 0;
public static void main(String[] args) {
m = 5;
n = 5;
int x = 0;
int y = 0;
map = new int[m][n];
jump(x, y);
System.out.println("---------");
System.out.println(count);
}
private static void jump(int x, int y) {
// 如果超出界限，那就繼續下一輪
if (x < 0 || x >= m || y < 0 || y >= n || map[x][y] != 0) {
return;
}
// 立足此節點
step++;
map[x][y] = step;
if (step == m * n) {
if (count == 0) // 如果是第一次，那就輸出一個
show(map);
count++;
}
// 寫出所有路徑（技巧）
int tx = 0, ty = 0;
for (int i = 0; i < 8; i++) {
tx = x + next[i][0]; // 技巧
ty = y + next[i][1];
jump(tx, ty);
}
// 還原
step--;
map[x][y] = 0;
}
// 顯示陣列
private static void show(int[][] arr) {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
System.out.print(arr[i][j] + " \t");
}
System.out.println();
}
}
}
```
**程式執行結果：**
## 八皇后
程式設計解決“八皇后問題”：即 在一個 8\*8 的矩形格子中排放 8 個皇后。
要滿足的條件包括：任意兩個皇后不能在同一行，同一列，也不能在同一條對角線上。
要求程式設計給出解的個數。
---
**答案：**
演算法原理：回溯法
首先，可歸納問題的條件為，8 皇后之間需滿足：
1. 不在同一行上
2. 不在同一列上
3. 不在同一斜線上
4. 不在同一反斜線上
這為我們提供一種遍歷的思路，我們可以**逐行**或者**逐列**來進行可行擺放方案的遍歷，每一行（列）遍歷出一個符合條件的位置，接著就到下一行（列）遍歷下一個棋子的合適位置，這種遍歷思路可以保證我們遍歷過程中有一個條件是絕對符合的——就是下一個棋子的擺放位置與前面的棋子**不在同一行**（列）。
這裡我們**逐列擺放**，**陣列下標代表列號，用陣列元素存放行號。**
把當前列 N 的前面的某一列設為 m,則 m 的所有取值為｛m>=0,m=0 ,與第 m 列的棋子不在同一斜線上）
- cols[N] != cols[m] + (N-m) （<=8-1,與第 m 列的棋子不在同一反斜線上）
我們規定當 row[i]=true 時，表示該列第 i 行不能放棋子。
**總結：**
- 編寫檢測函式：正如上面的分析，每擺一個，將不合法的位置用陣列標識，就不涉足了。當然，也可以寫成函式，不過沒有陣列快。
- 明確函式功能：put(n)為擺第n個皇后。
- 尋找遞迴出口：當擺完第八個皇后；不同行、不同斜線、不同反斜線。
- 明確所有路徑：八行。
- 回溯還原現場：不需要還原，沒有破壞現場，因為檢測的時候提前用陣列標識了，所以不合法的現場都沒涉足。
這樣我們就能寫成下列程式段了：
```
// 八皇后
class Sy6 {
public static int num = 0; // 累計方案總數
public static final int MAXQUEEN = 8;// 皇后個數，同時也是棋盤行列總數
public static int[] cols = new int[MAXQUEEN]; // 定義cols陣列，表示8列棋子擺放情況，陣列元素存放行號
public Sy6() {
// 核心函式
put(0);
System.out.println(MAXQUEEN + "皇后問題有" + num + "種擺放方法。");
}
public void put(int n) {
// 當擺完第八個皇后，擺第九個時
if (n > MAXQUEEN - 1) {
// 累計方案個數
num++;
return;
}
// 遍歷該列所有不合法的行，並用 rows 陣列記錄，不合法即 rows[i]=true
boolean[] rows = new boolean[MAXQUEEN];
for (int i = 0; i < n; i++) {
rows[cols[i]] = true; // 同行不合法
int d = n - i; // 列差
if (cols[i] - d >= 0) // 判斷是否超界
// 行差為-d的斜線點，不合法
rows[cols[i] - d] = true;
if (cols[i] + d <= MAXQUEEN - 1)// 判斷是否超界
// 行差為d的斜線點，不合法
rows[cols[i] + d] = true;
}
// 所有路徑：八行都能擺
for (int i = 0; i < MAXQUEEN; i++) {
// 判斷該行是否合法，如果不合法，那就繼續下一輪
if (rows[i])
continue;
// 設定當前列合法棋子所在行數
cols[n] = i;
// 擺放下一個
put(n + 1);
}
}
public static void main(String args[]) {
Sy6 queen = new Sy6();
}
}
```
**程式執行結果：**
![](https://img2020.cnblogs.com/blog/1542615/202003/1542615-20200308162804038-11275041