窮舉遞歸和回溯算法終結篇

時間 2019-11-11

原文原文鏈接

窮舉遞歸和回溯算法

在通常的遞歸函數中，如二分查找、反轉文件等，在每一個決策點只須要調用一個遞歸（好比在二分查找，在每一個節點咱們只須要選擇遞歸左子樹或者右子樹），在這樣的遞歸調用中，遞歸調用造成了一個線性結構，而算法的性能取決於調用函數的棧深度。好比對於反轉文件，調用棧的深度等於文件的大小；再好比二分查找，遞歸深度爲O(nlogn)，這兩類遞歸調用都很是高效。html

如今考慮子集問題或者全排列問題，在每個決策點咱們不在只是選擇一個分支進行遞歸調用，而是要嘗試全部的分支進行遞歸調用。在每個決策點有多種選擇，而這多種選擇的每個選擇又致使了更多的選擇，直到咱們碰到base case。這樣的話，隨着遞歸調用的深刻，窮舉遞歸(exhaustive recursion)算法時間複雜度就會很高。好比：在每一個決策點咱們須要肯定選擇哪一個一個字母或者在當前位置選擇下一步去哪一個城市（TSP）。那麼咱們有辦法避免代價高昂的窮舉遞歸嗎？答案是視狀況而定。在有些狀況下，咱們沒有辦法，必須窮舉遞歸，好比咱們須要找到全局的最優解。然而在更多的狀況下咱們只但願找到滿意解，在每一個決策點，咱們選擇只選擇一條遞歸調用路徑，但願它可以成功，若是咱們最終發現，能夠獲得一個滿意解，OK咱們再也不遍歷其餘的狀況了。不然若是此次嘗試沒有成功，咱們退回決策點，換一個選擇嘗試，這就是回溯算法。值得說明的是，關於回溯的深度，咱們只須要向上回溯到最近的決策點，該決策點知足還有其餘的選擇沒有嘗試。隨着回溯的向上攀升，最終咱們可能回到初始狀態，這時候其實咱們已經窮舉遞歸了全部的狀況，那麼該問題是不可解的。ios

典型問題回顧

上面說的是否是很抽象？我也以爲，可是沒辦法，嚴謹仍是要有的，說的再多不如來看幾個例子來得實在，畢竟咱們學習它是爲了解決實際問題的。git

【經典窮舉問題】窮舉全部的排列

問題描述：給定一個字符串，重排列後輸出全部可能的排列。算法

在每一個決策點，咱們須要在剩餘待處理的字符串中，選擇一個字母，假設剩餘字符串長度爲k，那麼在每一個決策點咱們有k種選擇，咱們對每一個選擇都嘗試一次，每次選擇一個後，更新當前已經字符串和剩餘字符串。當剩餘字符串爲空時，咱們到達base case，輸出當前選擇的字符串便可。僞代碼及C++代碼以下：ide

 1 // Permutation Problem
 2 // If you have no more characters left to rearrage, print the current permutation
 3 // for (every possible choice among the characters left to rearrage)
 4 // {
 5 //      Make a choice and add that character to the permutation so far
 6 //      Use recursion to rearrage the remaing letters
 7 // }
 8 //
 9 void RecursivePermutation(string sofar, string remain)
10 {
11     if (remain == "") {cout << sofar << endl; reutrn;}
12 
13     for (size_t i = 0; i < remain.size(); ++i)
14     {
15         string sofar2 = sofar + remain[i];
16         string remain2 = remain.substr(0, i) + remain.substr(i+1);
17         RecursivePermutation(sofar2, remain2);
18     }
19 }

在這個問題中，咱們嘗試了全部可能的選擇，屬於窮舉遞歸，總共有n!中排列方法。這是一個很是經典的模式，是許多遞歸算法的核心，好比猜字謎問題，數獨問題，最優化匹配問題，調度問題等均可以經過這種模式解決。函數

【經典窮舉問題】子集問題

問題描述：給定一個集合，列出該集合的全部子集oop

對於每個決策點，咱們從剩餘的集合中選擇一個元素後，有兩種選擇，子集包括該元素或者不包括該元素，這樣每次遞歸一步的話，剩餘集合中的元素就會減小一個，直到剩餘集合爲空，咱們到達base case。僞代碼及C++代碼以下：性能

 1 // Subset Problem
 2 //
 3 // If there are no more elements remaining, print current subset
 4 // Consider the next element of those remaining
 5 // Try adding it to current subset and use recursion to build subsets from here
 6 // Try not adding it to current subset and use recursion to build subsets from here
 7 void RecursiveSubset(string sofar, string remain)
 8 {
 9     // base case
10     if (remain == "") { cout << sofar << endl; return; }
11     
12     char ch = remain[0];
13     string remain2 = remain.substr(1);
14     RecursiveSubset(sofar, remain2);        // choose first element
15     RecursiveSubset(sofar + ch, remain2);   // not choose first element
16 }

這是另一個窮舉遞歸的典型例子。每次遞歸調用問題規模減小一個，然而會產生兩個新的遞歸調用，於是時間複雜度爲O(2^n)。這也是個經典問題，須要牢記解決該類問題的pattern，其餘與之相似的問題還有最優填充問題、集合劃分問題、最長公共子列問題（longest shared subsequence)等。學習

這兩個問題看起來很像，實際上差異很大，屬於不一樣的兩類問題。在permutation問題中，咱們在每次決策點是要選擇一個字母包含到當前子串中，咱們有n中選擇（假設剩餘子串長度爲n），每一次選擇後遞歸調用一次，於是有n個規模爲n-1的子問題，即T(n) = n T(n-1)。而對於subset問題，咱們在每一個決策點對於字母的選擇只能是剩餘子串的首字母，而咱們決策的過程爲選擇or not選擇（這是一個問題，哈哈），咱們拿走一個字母后，作了兩次遞歸調用（對比permutation問題，咱們拿下一個字母后只進行了一次遞歸調用），所以T(n) = 2 * T(n-1)。優化

總結說來：permutation問題拿走一個字母后，遞歸調用一次，咱們的決策點是有n個字母能夠拿；而subset問題是拿走一個字母后，進行了兩次遞歸調用，咱們的決策點是包括仍是不包括該拿下的字母，請仔細體味二者的區別。

遞歸回溯

在permutation問題和subset問題中，咱們探索了每一種可能性。在每個決策點，咱們對每個可能的選擇進行嘗試，知道咱們窮舉了咱們全部可能的選擇。這樣以來時間複雜度就會很高，尤爲是若是咱們有許多決策點，而且在每個決策點咱們又有許多選擇的時候。而在回溯算法中，咱們嘗試一種選擇，若是知足了條件，咱們再也不進行其餘的選擇。這種算法的通常的僞代碼模式以下：

 1 bool Solve(configuration conf)
 2 {
 3     if (no more choice)
 4         return (conf is goal state);
 5 
 6     for (all available choices)
 7     {
 8         try choice c;
 9 
10         ok = solve(conf with choice c made);
11         if (ok)
12             return true;
13         else
14             unmake c;
15     }
16 
17     retun false;
18 }

寫回溯函數的忠告是：將有關格局configuration的細節從函數中拿出去（這些細節包括，在每個決策點有哪些選擇，作出選擇，判斷是否成功等等），放到helper函數中，從而使得主體函數儘量的簡潔清晰，這有助咱們確保回溯算法的正確性，同時有助於開發和調試。

咱們先看第一個例子，從permutation問題中變異而來。問題是給定一個字符串，問是否可以經過從新排列組合一個合法的單詞？這個問題不須要窮舉全部狀況，只須要找到一個合法單詞便可，於是可用回溯算法加快效率。若是可以構成合法單詞，咱們return該單詞；不然返回空串。問題的base case是檢查字典中是否包含該單詞。每次咱們作出選擇以後遞歸調用，判斷作出當前選擇以後可否成功，若是能，再也不嘗試其餘可能；若是不能，咱們換一個別的選擇。代碼以下：

 1 string FindWord(string sofar, string rest, Dict& dict)
 2 {
 3     // Base Case
 4     if (sofar.empty())
 5     {
 6         return (dict.containWords(sofar)? sofar : "");
 7     }
 8 
 9     for (int i = 0; i < rest.size(); ++i)
10     {
11         // make a choice
12         string sofar2 = sofar + rest[i];
13         string rest2 = rest.substr(0, i) + rest.substr(i+1);
14         String found = FindWord(sofar2, rest2, dict);
15         
16         // if find answer
17         if (!found.empty()) return found;
18         // else continue next loop, make an alternative choice
19     }
20 
21     return "";

咱們能夠對這個算法進行進一步剪枝來早些避免進入「死衚衕」。例如，若是輸入字符串是"zicquzcal"，一旦你發現了前綴"zc"你就沒有必要再進行進一步的選擇，由於字典中沒有以「zc」開頭的單詞。具體說來，在base case中須要加入另外一種終止條件，若是sofar不是有效前綴，直接返回「」。

【經典回溯問題1】八皇后問題

問題是要求在8x8的國際象棋盤上放8個queue，要求不衝突。（即任何兩個queue不一樣行，不一樣列，不一樣對角線）。按照前面的基本範式，咱們能夠給出以下的僞代碼及C++代碼：：

#include <iostream>
#include <vector>
using namespace std;

// Start in the leftmose column
// 
// If all queens are placed, return true
// else for (every possible choice among the rows in this column)
//          if the queue can be placed safely there,
//             make that choice and then recursively check if this choice lead a solution
//          if successful, return true
//          else, remove queue and try another choice in this colunm
// if all rows have been tried and nothing worked, return false to trigger backtracking
const int NUM_QUEUE = 4;
const int BOARD_SIZE = 4;
typedef vector<vector<int> > Grid;

void PlaceQueue(Grid& grid, int row, int col);
void RemoveQueue(Grid& grid, int row, int col);
bool IsSafe(Grid& grid, int row, int col);
bool NQueue(Grid& grid, int curcol);
void PrintSolution(const Grid& grid);


int main()
{
    vector<vector<int> > grid(BOARD_SIZE, vector<int>(BOARD_SIZE, 0));
    if (NQueue(grid, 0))
    {
        cout << "Find Solution" << endl;
        PrintSolution(grid);
    }
    else
    {
        cout << "Cannot Find Solution" << endl;
    }

    return 0;
}

void PlaceQueue(Grid& grid, int row, int col)
{
    grid[row][col] = 1;
}

void RemoveQueue(Grid& grid, int row, int col)
{
    grid[row][col] = 0;
}

bool IsSafe(Grid& grid, int row, int col)
{
    int i = 0;
    int j = 0;

    // check row
    for (j = 0; j < BOARD_SIZE; ++j)
    {
        if (j != col && grid[row][j] == 1) return false;    
    }

    // check col
    for (i = 0; i < BOARD_SIZE; ++i)
    {
        if (i != row && grid[i][col] == 1) return false;
    }

    // check left upper diag
    for (i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
    {
        if (grid[i][j] == 1) return false;
    }

    // check left lower diag
    for (i = row + 1, j = col - 1; i < BOARD_SIZE && j >= 0; i++, j--)
    {
        if (grid[i][j] == 1) return false;
    }

    return true;
}

bool NQueue(Grid& grid, int curcol)
{
    // Base case
    if (curcol == BOARD_SIZE)
    {
        return true;
    }

    for (int i = 0; i < BOARD_SIZE;++i)
    {
        if (IsSafe(grid, i, curcol))
        {
            // try a choice
            PlaceQueue(grid, i, curcol);
            // if this choice lead a solution, return
            bool success = NQueue(grid, curcol + 1);
            if (success) return true;
            // else unmake this choice, try an alternative choice
            else RemoveQueue(grid, i, curcol);
        }
    }

    return false;
}

void PrintSolution(const Grid& grid)
{
    for (int i = 0; i < BOARD_SIZE; ++i)
    {
        for (int j = 0; j < BOARD_SIZE; ++j)
        {
            cout << grid[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

【經典回溯問題2】數獨問題

數獨問題能夠描述爲在空格內填寫1-9的數字，要求每一行每一列每個3*3的子數獨內的數字1-9出現一次且僅出現一次。通常數獨問題會實現填寫一些數字以保證解的惟一性，從而使得不須要暴力破解，只是使用邏輯推理就能夠完成。這一次讓咱們嘗試用計算機暴力回溯來獲得一個解。解決數獨問題的僞代碼及C++代碼以下：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cstdio>
using namespace std;

// Base Case: if cannot find any empty cell, return true
// Find an unsigned cell (x, y)
// for digit from 1 to 9
//        if there is not conflict for digit at (x, y)
//     assign (x, y) as digit and Recursively check if this lead to a solution
//     if success, return true
//     else remove the digit at (x, y) and try another digit
// if all digits have been tried and still have not worked out, return false to trigger backtracking

const int GRID_SIZE = 9;
const int SUB_GRID_SIZE = 3;
typedef vector<vector<int> > Grid;

bool IsSafe(const Grid& grid, int x, int y, int num);
bool FindEmptyCell(const Grid& grid, int& x, int& y);
bool Sudoku(Grid& grid);
void PrintSolution(const Grid& grid);

int main()
{
    freopen("sudoku.in", "r", stdin);    
    vector<vector<int> > grid(GRID_SIZE, vector<int>(GRID_SIZE, 0));
    for (int i = 0; i < GRID_SIZE; ++i)
    {
        for (int j = 0; j < GRID_SIZE; ++j)
        {
            cin >> grid[i][j];
        }
    }

    if (Sudoku(grid))
    {
        cout << "Find Solution " << endl;
        PrintSolution(grid);
        cout << endl;
    }
    else
    {
        cout << "Solution does not exist" << endl;
    }
    return 0;
}

bool Sudoku(Grid& grid)
{
    // base case
    int x = 0; int y = 0;
    if (!FindEmptyCell(grid, x, y)) return true;
    
    // for all the number 
    for (int num = 1; num <= 9; ++num)
    {
        if (IsSafe(grid, x, y, num))
        {
            // try one choice
            grid[x][y] = num;
            // if this choice lead to a solution
            if (Sudoku(grid)) return true;
            // otherwise, try an alternative choice
            else grid[x][y] = 0;
        }
    }

    return false;
}

bool IsSafe(const Grid& grid, int x, int y, int num)
{
    // check the current row
    for (int j = 0; j < grid[x].size(); ++j)
    {
        if (j != y && grid[x][j] == num) return false;
    }

    // check current col
    for (int i = 0; i < grid.size(); ++i)
    {
        if (i != x && grid[i][y] == num) return false;
    }

    // check the subgrid
    int ii = x / 3;
    int jj = y / 3;
    for (int i = ii * SUB_GRID_SIZE; i < (ii+1) * SUB_GRID_SIZE; ++i)
    {
        for (int j = jj * SUB_GRID_SIZE;  j < (jj+1) * SUB_GRID_SIZE; ++j)
        {
            if (i != x || j != y)
            {
                if (grid[i][j] == num) return false;
            }
        }
    }

    return true;
}

// Find next Empty Cell
bool FindEmptyCell(const Grid& grid, int& x, int& y)
{
    for (int i = 0; i < GRID_SIZE; ++i)
    {
        for (int j = 0; j < GRID_SIZE; ++j)
        {
            if (grid[i][j] == 0)
            {
                x = i;
                y = j;
                return true;
            }
        }
    }
    return false;
}

void PrintSolution(const Grid& grid)
{
    for (int i = 0; i < GRID_SIZE; ++i)
    {
        for (int j = 0; j < GRID_SIZE; ++j)
        {
            cout << grid[i][j] << " ";
        }
        cout << "\n";
    }
    cout << endl;
}

【經典回溯問題3】迷宮搜索問題

該問題在實現給定一些黑白方塊構成的迷宮，其中黑塊表示該方塊不能經過，白塊表示該方塊能夠經過，而且給定迷宮的入口和期待的出口，要求找到一條鏈接入口和出口的路徑。有了前面的題目的鋪墊，套路其實都是同樣的。在當前位置，對於周圍的全部方塊，判斷可行性，對於每個可行的方塊，就是咱們當前全部可能的choices；嘗試一個choice，遞歸的判斷是否可以致使一個solution，若是能夠，return true；不然，嘗試另外一個choice。若是全部的choice都不能致使一個成功解，return false。剩下的就是遞歸終止的條件，當前所在位置若是等於目標位置，遞歸結束，return true。C++代碼以下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

const int BOARD_SIZE = 4;
enum GridState {Gray, White, Green};

const int DIRECTION_NUM = 2;
const int dx[DIRECTION_NUM] = {0, 1};
const int dy[DIRECTION_NUM] = {1, 0};
typedef vector<vector<GridState> > Grid;


bool IsSafe(Grid& grid, int x, int y);
bool SolveRatMaze(Grid& grid, int curx, int cury);
void PrintSolution(const Grid& grid);


int main()
{
    vector<vector<GridState> > grid(BOARD_SIZE, vector<GridState>(BOARD_SIZE, White));
    for (int j = 1; j < BOARD_SIZE; ++j) grid[0][j] = Gray;
    grid[1][2] = Gray;
    grid[2][0] = Gray; grid[2][2] = Gray; grid[2][3] = Gray;

    // Place the init position
    grid[0][0] = Green;
    bool ok = SolveRatMaze(grid, 0, 0);
    if (ok)
    {
        cout << "Found Solution" << endl;
        PrintSolution(grid);
    }
    else
    {
        cout << "Solution does not exist" << endl;
    }

    return 0;
}


bool SolveRatMaze(Grid& grid, int curx, int cury)
{
    // base case
    if (curx == BOARD_SIZE - 1 && cury == BOARD_SIZE - 1) return true;

    // for every choice
    for (int i = 0; i <    DIRECTION_NUM; ++i)
    {
        int nextx = curx + dx[i];
        int nexty = cury + dy[i];
        if (IsSafe(grid, nextx, nexty))
        {
            // try a choice
            grid[nextx][nexty] = Green;
            // check whether lead to a solution
            bool success = SolveRatMaze(grid, nextx, nexty);
            // if yes, return true
            if (success) return true;
            // no, try an alternative choice, backtracking
            else grid[nextx][nexty] = White;
        }
    }

    // try every choice, still cannot find a solution
    return false;
}

bool IsSafe(Grid& grid, int x, int y)
{
    return grid[x][y] == White;
}

void PrintSolution(const Grid& grid)
{
    for (int i = 0; i < BOARD_SIZE; ++i)
    {
        for (int j = 0; j < BOARD_SIZE; ++j)
        {
            cout << grid[i][j] << " ";
        }
        cout << "\n";
    }
    cout << endl;
}

本文小結

遞歸回溯算法想明白了其實很簡單，由於大部分工做遞歸過程已經幫咱們作了。再重複一下，遞歸回溯算法的基本模式：識別出當前格局，識別出當前格局全部可能的choice，嘗試一個choice，遞歸的檢查是否致使了一個solution，若是是，直接return true；不然嘗試另外一個choice。若是嘗試了全部的choice，都不能致使一個解，return false從而觸發回溯過程。剩下的就是在函數的一開始定義遞歸終止條件，這個須要具體問題具體分析，通常狀況下是，當前格局等於目標格局，遞歸終止，return false。

在理解了遞歸回溯算法的思想後，記住經典的permutation問題和子集問題，剩下就是多加練習和思考，基本沒有太難的問題。在geekforgeeks網站有一個回溯算法集合Backtracking，題目很經典過一遍基本就沒什麼問題了。