2. 程式人生 > 其它 >程式碼手記筆錄——遞歸回溯

程式碼手記筆錄——遞歸回溯

阿新 • • 發佈：2022-05-13

遞歸回溯的兩種寫法

（1）遞歸回溯無非是向下走一直到遞迴基，然後向右走。這個 向右 的過程可以通過 for 迴圈控制 （迭代向右法） ，也可以通過控制下標遞迴控制 （下標遞歸向右法）
（2）遞歸回溯函式裡的 push() 與 pop() 個數一定是相等的。【注意：if-else裡的 pop() 只能算一次】
（3）為減少遞迴-回溯的時間，優化的方法是 剪枝
（4）遞歸回溯步驟是向下-向右，其實就暗含著搜尋答案存在 可以向右 的性質。對於給定的不滿足 向右遞迴就可以搜尋到全部答案 陣列，首先要讓該陣列滿足該條件。如對求 sum 的組合元素需 先對 nums 進行排序： 【39 組合總和 】、【40 組合總和 II】
（5）遞歸回溯為了避免 ans 的答案出現重複，需在 向右走

的時候進行處理，跳過會出現重複答案的搜尋路徑。如【40 組合總和 II】
（6）對於某些題目，在到達向下遞迴基時，無需向右走。【93 復原 IP 地址】

迭代向右法

迭代向右法模板如下：【push() 與 pop() 個數需相等】

void backtracking(vector<vector<int>> &ans, vector<int> &item, int idx, int n, int k) {
    if (...)  // 向右遞迴出口
        return;
    for (....) {  // （含剪枝條件）// for 迴圈向右同層遞迴
        item.push_back(curIdx);   // 若不是出口就可以直接 push_back
        if (....)   // 不滿足一組遞迴答案，繼續向下遞迴
            backtracking(ans, item, curIdx+1, n, k);  // 從上到下走
        else   
            ans.push_back(item);
        item.pop_back();   // push() 與 pop() 對應
    }
    
}

章節題目總結

39 組合總和

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> item;
        // 這道題有點坑，我們在進行操作之前必須使得給定陣列是升序排序的
        sort(candidates.begin(), candidates.end());
        backtracking(ans, item, 0, candidates, target);
        return ans;
    }
private:
    void backtracking(vector<vector<int>> &ans, vector<int> &item, int idx, vector<int>& candidates, int target) {
        if (idx >= candidates.size())
            return;
        int curNum = candidates[idx];
        // 採用push-pop結構
        item.push_back(curNum);
        target -= curNum;
        if (target <= 0) { // 停止向下遞迴
            if (target == 0)
                ans.push_back(item);
            item.pop_back();
            target += curNum;
        }
        else {
            backtracking(ans, item, idx, candidates, target); // 向下遞迴
            item.pop_back();
            target += curNum;
            backtracking(ans, item, idx+1, candidates, target); // 向右邊遞迴
        }
    }
};

40 組合總和 II

備註：排序預處理+while() 向右走的策略防止答案重複

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> item;
        sort(candidates.begin(), candidates.end());
        backtracking(ans, item, 0, candidates, target);
        return ans;
    }
private:
    void backtracking(vector<vector<int>> &ans, vector<int> &item, int idx, vector<int>& candidates, int target) {
        if (idx >= candidates.size())
            return;
        int curNum = candidates[idx];
        item.push_back(curNum);
        target -= curNum;
        if (target <= 0) {
            if (target == 0)
                ans.push_back(item);
            item.pop_back();
        }
        else {
            backtracking(ans, item, idx+1, candidates, target);
            item.pop_back();
            target += curNum;
            int tmpIdx = idx+1;
            while (tmpIdx<candidates.size() && candidates[tmpIdx] == candidates[idx])
                ++tmpIdx;
            backtracking(ans, item, tmpIdx, candidates, target);
        }
    }
};

下標遞歸向右法

下標遞歸向右法模板如下：

void backtracking(vector<vector<int>> &ans, vector<int> &item, int idx, int n, int k) {
    if (...)    // （含剪枝條件）向右遞迴出口
        return;
    item.push_back(idx);   // 若不是出口就可以直接 push_back
    if (....) {  // 不滿足一組遞迴答案，繼續向下遞迴
        backtracking(ans, item, idx+1, n, k);    // 從上到下走
        item.pop_back();  // 回溯
        backtracking(ans, item, idx+1, n, k);  // 從左到右走
    }
    else {   // 到達向下遞迴出口，只繼續向右遞迴
        ans.push_back(item);   // 記錄一組答案
        item.pop_back();  // 對 item.push_back(idx) 的呼應
        backtracking(ans, item, idx+1, n, k);   // // 從左到右走
    }
}

章節題目總結

131 分割回文串【高頻考題】

備註：（1）考點一：迴文串 dp 的遍歷順序；（2）遞歸回溯

迴文串的遍歷順序問題

首先回文字串 dp 初始化矩陣為下三角矩陣，且元素只為 1：

for (int i=0; i<n; ++i) {
  for (int j=i; j<n; ++j)
    dp[i][j] = 1;
}

然後明確字串 s[i:j] 是迴文串的條件=>s[i]==s[j] && dpSys[i+1][j-1]，即長元素 s[i:j] 的判定條件依賴於內部短元素 s[i+1:j-1]。因此遍歷順序應該從短字串開始：

for (int i=0; i<n; ++i) {
    for (int j=0; j<=i; ++j)
        dpSyms[i][j] = 1;
}
for (int i=n-1; i>=0; --i) {
    for (int j=i+1; j<n; ++j)
        dpSyms[i][j] = (s[i] == s[j]) && dpSyms[i+1][j-1];
}
131 分割回文串

對於此類涉及字元的題目（對比【17 電話號碼的字母組合】），適合用下標遞歸向右法。
備註：（1）竟然在 if(!cond) 犯迷糊，以後統一寫 if(cond > 0)；（2）如果整個字串能被分割，idx 就會到達 n，否則不會到達 n；因此在向右遞迴出口 Push Into ans 是正確的。

class Solution {
public:
    vector<vector<string>> ans;
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<int>> dpSyms(n, vector<int>(n, 0));
        init(dpSyms, s, n);
        vector<string> item;
        backtracking(dpSyms, item, s, 0);
        return ans;
    }
private:
    void init(vector<vector<int>> &dpSyms, string s, int n) {
        for (int i=0; i<n; ++i) {
            for (int j=0; j<=i; ++j)
                dpSyms[i][j] = 1;
        }
        for (int i=n-1; i>=0; --i) {
            for (int j=i+1; j<n; ++j)
                dpSyms[i][j] = (s[i] == s[j]) && dpSyms[i+1][j-1];
        }
    }
    void backtracking(vector<vector<int>> &dpSyms, vector<string> &item, string &s, int idx) {
        int n = s.size();
        if (idx >= n) {  // 向右走遞迴出口
            if (item.size()) 
                ans.push_back(item);
            return;
        }
        for (int j=idx; j<n; ++j) {  // 向右走
            if (dpSyms[idx][j]) {
                string curStr = s.substr(idx, j-idx+1);
                item.push_back(curStr);
                backtracking(dpSyms, item, s, j+1);  // 向下走
                item.pop_back();
            }
        }
    }
};

93 復原 IP 地址

備註：（1）這道題在到達向右遞迴基時無需向右走；（2）IP 每部分的合法性判斷

bool isValid(string s) {
    // 空 || 長度大於3 || 含有前導 0
    if (!s.size() || s.size()>3 || (s[0]=='0'&& s.size()>1))
        return false;
    int num = 0;
    for (auto data : s) 
        num = num*10 + data - '0';
    // 介於256-999
    if (num > 255)
        return false;
    return true;
}

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        vector<string> ans;
        if (s.size() > 12)
            return ans;
        vector<string> itemStr;
        backtracking(ans, itemStr, -1, 0, s);
        return ans;
    }
private:
    void backtracking(vector<string> &ans, vector<string> &itemStr, int preIdx , int curIdx, string &s) {
        if (curIdx >= s.size() || itemStr.size() >=4)
            return;
        string curNum = s.substr(preIdx+1, curIdx-preIdx);
        if (!isValid(curNum))
            return;
        itemStr.push_back(curNum);
        if (itemStr.size() == 4 && curIdx+1 >= s.size()) {
            string ansStr;
            for(int i=0; i<4; ++i) {
                if (i !=0)
                    ansStr.push_back('.');
                ansStr += itemStr[i];
            }
            ans.push_back(ansStr);
            itemStr.pop_back();
        }
        else {
            backtracking(ans, itemStr, curIdx, curIdx+1, s);  // 向下移動
            itemStr.pop_back();
            backtracking(ans, itemStr, preIdx, curIdx+1, s);  // 向右移動
        }
    }
    bool isValid(string s) {
        // 空 || 長度大於3 || 含有前導 0
        if (!s.size() || s.size()>3 || (s[0]=='0'&& s.size()>1))
            return false;
        int num = 0;
        for (auto data : s) 
            num = num*10 + data - '0';
        // 介於256-999
        if (num > 255)
            return false;
        return true;
    }
};

相關推薦

程式碼手記筆錄——遞歸回溯

遞歸回溯的兩種寫法 （1）遞歸回溯無非是向下走一直到遞迴基，然後向右走。這個 向右 的過程可以通過 for 迴圈控制 （迭代向右法） ，也可以通過控制下標遞迴控制 （下標遞歸向右法）

python 使用遞歸回溯完美解決八皇后的問題

八皇后問題描述：在一個8✖️8的棋盤上，任意擺放8個棋子，要求任意兩個棋子不能在同一行，同一列，同一斜線上，問有多少種解法。

非遞歸回溯法實現0-1揹包問題

技術標籤：演算法設計與分析c++演算法 來，捏捏大佬牛子：https://blog.csdn.net/peachhhh/article/details/111475680

332重新安排行程（遞歸回溯dfs深度優先搜尋）

技術標籤：LeetCodeleetcode演算法 1、題目描述 給定一個機票的字串二維陣列 [from, to]，子陣列中的兩個成員分別表示飛機出發和降落的機場地點，對該行程進行重新規劃排序。所有這些機票都屬於一個從 JFK（肯尼

用遞歸回溯解決八皇后問題

技術標籤：演算法學習學習筆記演算法資料結構 思想 理論上應該建立一個二維陣列來表示棋盤，但是實際上可以通過演算法，用一個一維陣列即可解決問題. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} arr 下標表示第幾行，

迷宮遞歸回溯問題

package com.itheima.Main; import java.io.IOException; /** * 迷宮回溯問題 */ public class Main { public static void main(String[] args) throws IOException {

程式碼手記筆錄——優先佇列與單調佇列

優先佇列 參考：https://zhuanlan.zhihu.com/p/478887055 優先佇列採用堆結構儲存資料，高優先順序大頂堆。 可以重寫比較器 cmp 設定優先級別。對於基本資料型別，預設為數值大的優先順序高：

程式碼手記筆錄——二叉樹

寫在前面 （1）二叉樹遍歷順序包括先序遍歷、中序遍歷、後序遍歷。二叉樹遍歷實現包括迭代實現、遞迴實現。

【C/C++】n皇后問題/全排列/遞迴/回溯/演算法筆記4.3

按常規，先說一下我自己的理解。 遞迴中的return常用來作為遞迴終止的條件，但是對於返回數值的情況，要搞明白它是怎麼返回的。遞迴的方式就是自己呼叫自己，而在有返回值的函式中，上一層的函式還沒執行完就呼叫下

遞迴演算法1：程式碼對稱中間遞迴

技術標籤：java 遞迴演算法1：程式碼對稱中間遞迴 例子1：例子2： 下面兩個例子的遞迴思想是一樣的，很簡潔和有意思！

遞迴——回溯思路解決 n 皇后問題

技術標籤：機試準備 一般來說，如果在到達遞迴邊界的某層，由於一些事實導致已經不需要任何一個子問題遞迴就可以直接返回上一層，把這種做法稱為回溯法。

39--組合總和（遞迴+回溯）

題目 給你一個 無重複元素 的整數陣列 candidates 和一個目標整數 target ，找出 candidates 中可以使數字和為目標數 target 的 所有 不同組合 ，並以列表形式返回。你可以按 任意順序 返回這些組合。

springboot + vue 實現遞迴生成多級選單(例項程式碼)

開發過程中，涉及到多級選單的應用，找了一些資料案例實現如下（使用springboot+layui+oracle）：

Java遞迴遍歷檔案目錄程式碼例項

這篇文章主要介紹了Java遞迴遍歷檔案目錄程式碼例項,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Python通過遞迴獲取目錄下指定檔案程式碼例項

這篇文章主要介紹了python通過遞迴獲取目錄下指定檔案程式碼例項,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Python 實現遞迴法解決迷宮問題的示例程式碼

迷宮問題 問題描述： 迷宮可用方陣 [m,n] 表示，0 表示可通過，1 表示不能通過。若要求左上角 (0,0) 進入，設計演算法尋求一條能從右下角 (m-1,n-1) 出去的路徑。

Python遞迴呼叫實現數字累加的程式碼

我就廢話不多說了，直接上程式碼吧！ def sum_numbers(num): # 1.出口 if num == 1: return 1

基於Python資料結構之遞迴與回溯搜尋

目錄 1. 遞迴函式與回溯深搜的基礎知識 2. 求子集 (LeetCode 78) 3. 求子集2 (LeetCode 90)

python實現全排列程式碼(回溯、深度優先搜尋)

從n個不同元素中任取m（m≤n）個元素，按照一定的順序排列起來，叫做從n個不同元素中取出m個元素的一個排列。當m=n時所有的排列情況叫全排列。

Python遞迴實現列印多重列表程式碼

廢話不多說，我直接上程式碼吧！ # 遞迴方法列印多重列表 li = [1,[[2,[3]],[4],5],6,7,[8],9,10]