回溯策略
歡迎大家訪問我的個人搭建的博客Vfdxvffd's Blog
回溯是五大常用算法策略之一，它的核心思想其實就是將解空間看作是一棵樹的結構，從樹根到其中一個葉子節點的路徑就是一個可能的解，根據約束條件，即可得到滿足要求的解。求解問題時，發現到某個節點而不滿足求解的條件時，就“回溯”返回，嘗試別的路徑。回溯法是一種選優搜索法，按選優條件向前搜索，以達到目標。下面通過幾個例子來討論這個算法策略。
貨郎問題
有一個推銷員，要到n個城市推銷商品，他要找出一個包含所有n個城市的具有最短路程的環路。（最后回到原來的城市），也就是說給一個無向帶權圖G<V,E>,用一個鄰接矩陣來存儲兩城市之間的距離（即權值），要求一個最短的路徑。
我們設置一組數據如下：4個城市，之間距離如下圖所示，默認從0號城市出發
由此我們可以畫出一棵解空間樹：（只畫了一部分，右邊同理）
按照這個解空間樹，對其進行深度優先搜索，通過比較即可得到最優結果（即最短路徑）
package BackTrack;
//解法默認從第0個城市出發，減小了問題難度，主要目的在於理解回溯策略思想
public class Saleman {
//貨郎問題的回溯解法
static int[][] map = {
{ 0,10,5,9},
{10,0,6,9},
{ 5,6,0,3},
{ 9,9,3,0}
}; //鄰接矩陣
public static final int N = 4; //城市數量
static int Min = 10000; //記錄最短的長度
static int[] city = {1,0,0,0}; //默認第0個城市已經走過
static int[] road = new int[N]; //路線，road[i] = j表示第i個城市是第j個經過的
/**
*
* @param city 保存城市是否被經過，0表示未被走過，1表示已經走過
* @param j 上一層走的是第幾個城市
* @param len 此時在當前城市走過的距離總和
* @param level 當前所在的層數，即第幾個城市
*/
public static void travel(int[] city, int j, int len, int level) {
if(level == N - 1) { //到達最后一個城市
/*do something*/
if(len+map[j][0] < Min) {
Min = len + map[j][0];
for (int i = 0; i < city.length; i++) {
road[i] = city[i];
}
}
return;
}
for(int i = 0; i < N; i++) {
if(city[i] == 0 && map[j][i] != 0) { //第i個城市未被訪問過，且上一層訪問的城市並不是此城市
city[i] = level+2; //將此城市置為已訪問
travel(city, i, len+map[j][i], level+1);
city[i] = 0; //嘗試完上一層的路徑后，將城市又置為未訪問，以免影響后面的嘗試情況，避免了clone數組的情況，節省內存開銷
}
}
}
public static void main(String[] args) {
travel(city,0,0,0);
System.out.println(Min);
for (int i = 0; i < N; i++) {
System.out.print(road[i]+" ");
}
System.out.println("1");
}
}
八皇后問題
要在n*n的國際象棋棋盤中放n個皇后，使任意兩個皇后都不能互相吃掉。規則：皇后能吃掉同一行、同一列、同一對角線的任意棋子。求所有的解。n=8是就是著名的八皇后問題了。
用一個position數組表示皇后的擺放位置，position[i] = j表示第i行皇后放在第j列，我們從第一行開始，對每一列進行嘗試擺放，如果可行則繼續第二行，同理第二行繼續對每一列進行嘗試，如果發現某一行不管放在哪一列都不可行，說明上面某行的擺放是不可行的，則回溯到上面一行，從擺放的那一列接着往下嘗試......
這道題的解空間樹非常龐大，第一層8個節點，然后往下每一個節點又有8個孩子（包含了所有可行和不可行解，但都要嘗試過去），所以有8^8種可能解。
public class Empress {
final static int N = 8; //皇后個數
static int count = 0; //輸出的結果個數
static int[] postion = new int[N]; //保存每一行皇后擺放的位置，position[i] = j表示第i行皇后放在第j列
/**
* @param row 判斷第row行擺放是否合理
* @return 合理返回true，否則false
*/
public static boolean IsOk(int row){
for (int i = 0; i < row; i++) { //和前面的每一行進行對比
if(postion[i] == postion[row] || Math.abs(i-row) == Math.abs(postion[i] - postion[row])){
//如果在同一列則postion[i] == postion[row]
//如果在同一斜線上Math.abs(i-row) == Math.abs(postion[i] - postion[row])
return false;
}
}
return true;
}
public static void Print(){
System.out.println("This is the No."+(++count)+" result:");
for (int i = 0; i < N; i++) { //i為行序號
for (int j = 0; j < N; j++) { //j為第i行皇后的列的序號
if(postion[i] == j){ //不是皇后的拜訪地址
System.out.print("# ");
}else{
System.out.print("@ ");
}
}
System.out.println(); //換行
}
}
/**
* @param row 嘗試第row行皇后的擺放位置，找到可行位置就繼續深度搜索下一行，否則在嘗試完i的所有取值無果后回溯
*/
public static void backtrack(int row){
if(row == N){ //若已經等於N，則說明0~N-1已經賦值完畢，直接打印返回
Print();
return;
}
for (int i = 0; i < N; i++) {
postion[row] = i; //第row行皇后的位置在i處
if(IsOk(row)){
backtrack(row+1);
}else{
/**
* 如果第row行的皇后拜訪在i(0-N)處可行，則繼續向下深度搜索，否則就直接讓這層遞歸函數出棧
* 此層函數出棧也就是當前結點不滿足繼續搜索的限制條件，即回溯到上一層，繼續搜索上一層的下一個i值
*/
}
}
}
public static void main(String[] args) {
backtrack(0);
}
}
0-1背包的回溯解法
給定n個重量為w1，w2，w3，...，wn，價值為v1，v2，v3，...，vn的物品和容量為C的背包，求這個物品中一個最有價值的子集，使得在滿足背包的容量的前提下，包內的總價值最大。
這個問題的解空間樹是一棵決策樹，每個節點都有兩個孩子節點，分別對應了是否將這個物品裝入背包的兩種情況，0表示不裝入，1表示裝入，則我們可以畫出3件物品的解空間樹
package BackTrack;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Package {
//0-1背包問題，回溯解法
public static final int N = 5; //物品數量
static int[] values = {4,5,2,1,3}; //物品的價值
static int[] weights = {3,5,1,2,2}; //物品的質量
public static final int C = 8; //背包的容量
static int MAX = -1; //記錄最大的價值
static int[] bag = {0,0,0,0,0}; //物品放置情況，bag[i] = 0表示第i個物品未被裝入，等於1則表示已裝入
static List<int[]> list = new LinkedList<int[]>(); //保存最優的結果，可能有多個結果，所以用鏈表裝
public static boolean IsOk(int[] bag, int level) { //判斷當前背包是否超重
int weight = 0;
for (int i = 0; i <= level; i++) { //計算當前背包中所有的物品的總質量
if(bag[i] == 1) { //bag[i] == 1表示這個物品已被裝入背包
weight += weights[i];
if(weight > C)
return false;
}
}
return true;
}
public static void MaxValue(int[] bag, int level) {
if(level == N) { //已經判斷完最后一個物品
//先計算當前總價值
int value = 0;
for (int i = 0; i < N; i++) {
if(bag[i] == 1) {
value += values[i];
}圓排列
}
if(value > MAX) {
list.clear(); //發現更優的結果
MAX = value;
list.add(bag.clone());
}else if (value == MAX) { //其他放置情況的最優解
list.add(bag.clone());
}
return;
}
for (int i = 0; i < 2; i++) {
bag[level] = i;
if(IsOk(bag, level)) {
MaxValue(bag, level+1);
}
}
}
public static void main(String[] args) {
MaxValue(bag, 0);
System.out.println(MAX);
Iterator<int[]> iter = list.iterator();
while(iter.hasNext()) {
int[] temp = iter.next();
for (int i = 0; i < temp.length; i++) {
System.out.print(temp[i]+" ");
}
System.out.println();
}
}
}
圖的着色問題
給定無向連通圖G=(V, E)和m種不同的顏色，用這些顏色為圖G的各頂點着色，每個頂點着一種顏色。是否有一種着色法使G中相鄰的兩個頂點有不同的顏色?
這個問題是圖的m可着色判定問題。若一個圖最少需要m種顏色才能使圖中每條邊連接的兩個頂點着不同顏色，則稱這個數m為該圖的色數。求一個圖的色數m的問題稱為圖的m可着色優化問題。
編程計算：給定圖G=(V, E)和m種不同的顏色，找出所有不同的着色法。
形如下面這種情況：
采用回溯策略，對每一個頂點用每一個顏色作嘗試，按上圖這個例子，3種顏色為這個4個頂點的圖着色的解空間樹（包括所有可能解和不可能解）有34個可能解。即mn個可能解（m為顏色種數，n為節點個數）。
package BackTrack;
import java.util.Scanner;
public class Paint {
static int[][] p_Maxtrix = new int[4][4]; //圖的鄰接矩陣
static int Colornum = 3; //顏色數目
static int[] result = {-1,-1,-1,-1}; //保存結果
/**
* @param index 當前頂點的下標
* @param color 顏色的編號
* @return 染色方案是否可行
*/
public static boolean IsOk(int index, int color) { //判斷是否可以染色
for (int i = 0; i < p_Maxtrix.length; i++) {
if(p_Maxtrix[index][i] == 1 && result[i] == color) {
return false;
}
}
return true;
}
public static void backtrack(int index) {
if(index == p_Maxtrix.length) { //完成最后一個頂點的着色，輸出其中一種結果
for (int i = 0; i < result.length; i++) {
System.out.print(result[i]+" ");
}
System.out.println();
return;
}
for (int i = 0; i < Colornum; i++) { //對每一種顏色進行嘗試
result[index] = i;
if(IsOk(index, i)) {
backtrack(index+1);
}
result[index] = -1;
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
for (int i = 0; i <p_Maxtrix.length ; i++) {
for (int j = 0; j < p_Maxtrix.length; j++) {
p_Maxtrix[i][j] = in.nextInt();
}
}
backtrack(0);
}
}
圓排列問題
給定n個大小不等的圓c1,c2,…,cn，現要將這n個圓排進一個矩形框中，且要求各圓與矩形框的底邊相切。圓排列問題要求從n個圓的所有排列中找出有最小長度的圓排列。例如，當n=3，且所給的3個圓的半徑分別為1，1，2時，這3個圓的最小長度的圓排列如圖所示。其最小長度為
。
算法思路：將每個圓在每個位置上的所有可能作全排列，找出最短距離。
-
swap函數：用於交換圓之間的順序，將兩個圓互換位置。
-
center函數：計算第t個圓的圓心的坐標，用於給x數組賦值。
-
compute函數：其實是在當將最后一個圓排列完成后的操作，計算出當前的排列的距離，與已知的最優解比較，若更優就更新最優解。
-
backtrack函數：對每一種排列組合進行回溯嘗試。
參考博文：圓排列
package BackTrack;
public class Round {
public static final int N = 3; //圓的數目
static double min = 1000; //最短距離
static double[] x = new double[N]; //每個圓的圓心
static int[] r = {1,1,2}; //每個圓的半徑
static int[] best = new int[N]; //最優解
//交換函數，交換某兩個圓的位置
public static void swap(int[] a, int x, int y) {
int temp1 = a[x];
int temp2 = a[y];
a[x] = temp2;
a[y] = temp1;位置
}
/**
* 對為什么要使用循環做一解釋：
* 因為可能存在第x個圓，它太過於小，而導致其對第x-1和x+1，甚至其他的圓來說，第x個圓存在於不存在都是沒影響的
* 取x-1，和x+1來說：可能x太小，x+1與x-1相切，所以計算第x+1圓心坐標的時候，只能以x-1的圓心與它的圓心來計算
* 所以要每次循環比較選擇最大的那一個做半徑
* 可以參考https://blog.csdn.net/qq_37373250/article/details/81477394中的圖
*/
public static double center(int t) {
double max = 0.0; //默認第一個圓的圓心是0.0
for(int i = 0; i < t; i++) {
double temp = x[i]+2.0*Math.sqrt(r[i]*r[t]); //計算得到“以第i個圓的半徑和待計算圓的半徑”得出的圓心
//取最大值
if(temp > max) {
max = temp;
}
}
return max;
}
/**
* 針對為什么不能直接temp = x[N-1]+x[0]+r[N-1]+r[0]（直接用第一個圓到最后一個圓的圓心距離加上兩圓半徑）做一解釋：
* 為避免第一個圓太小，而第二個圓太大，而導致第二個圓的邊界甚至超過了第一個圓的邊界，最右邊同理
* 那也可以依次推出可能第三個，第四個...的邊界超過了第一個圓的邊界，右邊同理，所以需要每一個都做一下比較
* 但是可以放心，x是按圓當前排列順序放置圓心坐標的
*/
public static void compute() { //計算按此排列得到的結果
double low = 0, high = 0; //分別表示最左邊的邊際，和最右邊的邊際
for(int i = 0; i < N; i++) {
if(x[i]-r[i] < low) {
low = x[i]-r[i];
}
if(x[i]+r[i] > high) {
high = x[i]+r[i];
}
}
double temp = high - low;
if(temp < min) {
min = temp;
for (int i = 0; i < N; i++) {
best[i] = r[i];
}
}
}
public static void backtrack(int t) {
if(t == N) {
compute();
//return;
}
for(int i = t; i < N; i++) { //t之前的圓已經排好順序了，可能不是最優解，但是一種可能解
swap(r, t, i);
double center_x = center(t);
x[t] = center_x;
backtrack(t+1);
/*下面是使用了較為簡陋的剪枝算法進行優化
if(center_x+r[i] < min) {
x[t] = center_x;
backtrack(t+1);
}
*/
swap(r, t, i); //恢復交換之前的
}
}
public static void main(String[] args) {
backtrack(0);
for (int i = 0; i < N; i++) {
System.out.print(best[i]+" ");
}
System.out.println();
System.out.println(min);
}
}
連續郵資問題
假設國家發行了n種不同面值的郵票，並且規定每張信封上最多只允許貼m張郵票。連續郵資問題要求對於給定的n和m的值，給出郵票面值的最佳設計，在1張信封上可貼出從郵資1開始，增量為1的最大連續郵資區間。例如，當n=5和m=4時，面值為(1,3,11,15,32)的5種郵票可以貼出郵資的最大連續郵資區間是1到70。
解法思路：解決這個問題其實不光用到回溯，還用到了前面的動態規划策略。
- 首先要明確必須要有一張面值為1的郵票，否則連剛開始一元的郵資都無法貼出。
- 然后就是第x張郵票的面值必須介於第x-1張郵票的面值+1和前x-1張郵票所能貼出的最大郵資+1之間（閉區間）
- 明確前面兩點后，回溯的方法就很簡單了。每層都是在上一層的面值+1和上一層最大郵資+1之間對所有的可能進行嘗試求解最優解。
- 最后就是dp求解每一層的最大郵資問題了。拆解來看，分為向下dp和向右dp，具體dp的理解方法可以參考這篇博文，一些細節問題在下面注釋中寫出來了。連續郵資問題
package BackTrack;
public class Postage {
public static final int MAX_Postage = 300; //最大郵資不應該超過這個值
public static final int N = 6; //所用郵票張數
public static final int M = 5; //所用面值種數
public static int[] best = new int[M+1]; //存放最優解，即所有的面值best[0]不用於存儲
public static int[] x = new int[M+1]; //當前解
public static int MAX = 0; //最大郵資
public static int[][] dp = new int[M+1][MAX_Postage]; //用於動態規划保存第x[0]到x[cur]的最大郵資，dp[i][j] = k表示用i種面值的郵票表示j元最少需要k張
//應該將dp數組初始化到dp[1][i] = i; 即讓第一層都等於張數
public static int findMax(int cur) {
if(cur == 1) { //第一層，只能用面值為1的，能表達出的最大郵資為N（張數）
return N;
}
//向下dp
int j = 1; //指示列坐標
while (dp[cur-1][j] != 0) {
//此處dp的思路其實就是利用動態規划解決0-1背包問題時的思路，對新加入面值的郵票用與不用？用了用幾張的問題？
//不用時
dp[cur][j] = dp[cur-1][j];
//用的時候，用幾張？
for(int i = 1; i*x[cur] <= j; i++) { //i表示面值張數
int temp = dp[cur-1][j-i*x[cur]] + i; //dp[cur-1][j-i*x[cur]]表示除了新加入的面值之外前面所有的面值共同表達j-i*x[cur]元所需張數
dp[cur][j] = Math.min(temp, dp[cur][j]); //取最小的張數
}
j++;
}
//向右dp
while(true) {
int temp = MAX_Postage;
for(int i = 1; i <= cur; i++) {
/**
* 這里很妙，因為向右dp時每次都是向右一個一個推進，所以我們從x[]的第一種面值開始往上加，直到超過限制張數，那么如果x[]的
* 第二種面值剛好能將前面的多個第一種替換，那就替換更新張數
* 反正意思就是每一次for循環是對前面的較小面值的郵票是一個濃縮的過程
*/
temp = Math.min(dp[cur][j-x[i]]+1, temp);
}
if(temp > N || temp == MAX_Postage) { //不管怎么使用當前解x[]中的已知面值，都不能在張數限制內表達出j元
break;
}else {
dp[cur][j] = temp;
}
j++;
}
/**對下面這條語句做一個解釋
* 確保同一層上一次dp的結果不會影響下一次**嘗試**時的dp，因為可能上一次嘗試的一個分支中dp時已經給dp[2][10]賦過值了，但如果沒有這一句
* 就會導致后面的某次嘗試時一個分支中dp的時候，向下dp的時候直接將dp[2][10]向下dp了，而事實上，應該向右dp的時候才給dp[2][10]賦值的
* 其實就是向回溯的下一層發一個信號，表示這塊是我上一層dp停止的地方，過了這塊可能就是別的回溯分支給dp賦的值了
*/
dp[cur][j] = 0;
return j-1;
}
public static void backtrack(int t) { //t表示當前層數
if(t == M) { //已經選夠最多的面值種類
int max = findMax(t);
if(max > MAX) {
MAX = max;
for (int i = 0; i < best.length; i++) {
best[i] = x[i];
}
}
//return;
}else {
int temp = findMax(t); //得到當前層的最大郵資
for(int i = x[t]+1; i <= temp+1; i++) {
x[t+1] = i;
backtrack(t+1);
}
}
}
public static void main(String[] args) {
for (int i = 0; i <= N; i++) {
dp[1][i] = i;
}
x[0] = 0;
x[1] = 1;
backtrack(1);
System.out.println(MAX);
for (int i = 0; i < best.length; i++) {
System.out.print(best[i]+" ");
}
}
}