【力扣】組合總和3（組合的去重）

問題描述

注意，如果陣列裡有兩個元素的值相同，那麼這兩個元素是可以出現在同一個組合裡的：

但是：如果按前面的思路分析的話，會發現結果中出現很多相同的組合。
像這樣：

這很明顯是由於兩個相同的1造成的，因為當前的startindex對應第一個1時，向下一層遞迴後，starindex定位的還是1,。

如果用這種方法，在錄入結果時剔除重複的結果，則有可能在某些極端的樣例裡造成超時。
問題在於，我們在跳過多餘的1時，要注意只能在同層列舉時跳過，如果在向下遞迴時跳過，就會忽略1,1,6這個組合，並且在跳過時只能跳過後面的重複元素，否則也得不到1,1,6
得到這樣的處理方式

每一個迴圈代表一層的逐個列舉，每一個遞迴呼叫代表向下一層的深入
一定要注意哪裡是水平的，哪裡是垂直的。
程式碼如下：

class Solution {
public:
    vector<vector<int> > res;
    vector<int> path;
    void backtrace(vector<int>& candidates, int target, int startindex){
	if(accumulate(path.begin(), path.end(),0) >= target){
	//if(accumulate(path) >= target){
		if(accumulate(path.begin(), path.end(),0) == target){
			// for(int i = 0; i < res.size(); i++){
			// 	if(path == res[i]){
			// 		return ;
			// 	}
			// }
			res.push_back(path);
		}
		return ;
	}
	
	for(int i = startindex; i < candidates.size(); i++){
        if(i != startindex && (candidates[i] == candidates[i - 1])){
			//cout<<"遇到了第二個1"<<endl;
			continue;
		}
		path.push_back(candidates[i]);
//		int gap = 1;
//		while(candidates[i+gap] == candidates[i]){
//			gap++;
//		}
		backtrace(candidates, target, i + 1);
		path.pop_back();
	}
}//void 
vector<vector<int> > combinationSum2(vector<int>& candidates, int target) {
    res.clear();
	path.clear();
	sort(candidates.begin(), candidates.end());
	backtrace(candidates, target, 0);
	return res; 
}
};

再看一下程式碼隨想錄的思路：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            // used[i - 1] == true，說明同一樹枝candidates[i - 1]使用過
            // used[i - 1] == false，說明同一樹層candidates[i - 1]使用過
            // 要對同一樹層使用過的元素進行跳過
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); // 和39.組合總和的區別1，這裡是i+1，每個數字在每個組合中只能使用一次
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        path.clear();
        result.clear();
        // 首先把給candidates排序，讓其相同的元素都挨在一起。
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

思路可以說基本一樣，只不過他跳過同層重複元素的處理方式不一樣，用了一個used陣列記錄狀態。