回溯演算法

例題：leetcode38
https://leetcode-cn.com/problems/combination-sum/

回溯是一種有條件的窮舉方式，窮舉每一步，直到某一步檢查到當前的情況的不符合要求，在回退一步，選擇另一種情況進行窮舉。

回溯有一個模板可以參考，針對不同問題做出相應的調整

void util(...){
	//回溯條件
	if(...) return;
	else{
		for(...){
		//儲存資料
		save();
		//遞迴探索
		util(.....);
		//回溯之後，要麼當前資料不符合條件，要麼符合已經記錄，需要清除資料記錄下一種情況
		delete();
	}
}

 

針對例題

給你一個 無重複元素 的整數陣列 candidates 和一個目標整數 target ，找出 candidates 中可以使數字和為目標數 target 的 所有 不同組合 ，並以列表形式返回。你可以按 任意順序 返回這些組合。
candidates 中的 同一個 數字可以 無限制重複被選取 。如果至少一個數字的被選數量不同，則兩種組合是不同的。

例子[2,3,6,7]，7畫圖表示其搜尋過程

直接套用上述模板，程式碼如下

class Solution {
private:
    vector<vector<int>> res;
    int l;
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        this->l=candidates.size();
        vector<int> path;
        util(path,target,candidates);
        return res;
    }

    void util(vector<int>& path,int target,vector<int>& candidates){
	//回溯條件
        if(target<0) return;
	//找到符合要求的結果，紀律結果，回溯
        if(target==0) {res.emplace_back(path); return;}
        else{
            for(auto i:candidates){
		//記錄資料
                path.emplace_back(i);
                util(path,target-i,candidates);
		//清除資料
                path.pop_back();
            }
        }
    }
};
 

輸入
[2,3,6,7]
7
實際輸出
[[2,2,3],[2,3,2],[3,2,2],[7]]
期望輸出
[[2,2,3],[7]]
觀察上圖就能看出原因，我們記錄了符合條件的不同排列，而結果只需要一個
解決方法是，每次for從“本數字”開始，不要每次都從第一個數字開始

void util(vector<int>& path,int target,vector<int>& candidates,int s){
    if(target<0) return;
    if(target==0) {res.emplace_back(path); return;}
    else{
        for(s;s<l;s++){   //每次迴圈從當前開始
            path.emplace_back(candidates[s]);
            util(path,target-candidates[s],candidates,s);
            path.pop_back();
        }
    }
 

然而此種方法還不是最優解
觀察上圖，不難發現cand陣列遞增的時候，到探測到target-cand[i]<0時，其後的都不可能是結果，可以跳過，此步就是“剪枝”操作

class Solution {
private:
    vector<vector<int>> res;
    int l;
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        this->l=candidates.size();
        vector<int> path;
        //有序的cand才能實現剪枝
        sort(candidates.begin(),candidates.end());
        util(path,target,candidates,0);
        return res;
    }

    void util(vector<int>& path,int target,vector<int>& candidates,int s){
        //回溯
        if(target<0) return;
        if(target==0) {res.emplace_back(path); return;}
        else{
            for(s;s<l;s++){
                //剪枝
                if((target-candidates[s])<0) break;
                path.emplace_back(candidates[s]);
                util(path,target-candidates[s],candidates,s);
                path.pop_back();
            }
        }
    }
};