BackTrack

vector<vector<int>> result;
vector<int> path;

if(path.size() == 2){
    result.push_back(path)
    }

sum += i;
path.push_back(sum);
backtrack(sum,i);
sum -= i;
path.pop_back();

void backtracking(参數) {
    if (終止條件) {
        存放结果;
        return;
    }
 
    for (選擇：本層集合元素(通常是遍歷目的數組或數字) ) {
        處理節點;
        backtracking(路徑，選擇列表); // 選擇列表通常為選擇的順序遞增
        回歸原本狀態;
    }
}
 

class Solution {
public:
        vector<vector<int>> result;
        vector<int> path;
    void backtrack(int n,int k,int start){
        if(path.size() == k) {
            result.push_back(path);
            return;
        }
        for(int i=start;i<=n;i++){
            path.push_back(i);
            backtrack(n,k,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        backtrack(n,k,1);
        return result;
    }
};

class Solution {
public:
      vector<vector<int>> result;
        vector<int> path;
    void backtrack(int target,int k,int sum,int start){
        if(path.size() == k){
            if(sum == target){
                result.push_back(path);
                return ;
            }
        }
        for(int i=start;i<=9;i++){
            sum += i;
            path.push_back(i);
            backtrack(target,k,sum,i+1);
            sum -= i;
            path.pop_back();
        }
 
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        backtrack(n,k,0,1);
        return result;
    }
};

// @leet start
#include <string>
#include <unordered_set>
using namespace std;
class Solution {
public:
 
    int dfs(int start,string &s,unordered_set<string>&us){
    int maxSpliteSize = 0;
    if(start == s.size()){
      return -1;
    }
    for(int i=start+1;i<=s.size();i++){
      string subString = s.substr(start,i-start);
      if(us.find(subString) == us.end()){
        us.insert(subString);
        maxSpliteSize = max(maxSpliteSize,1+dfs(i,s,us));
        us.erase(subString);
      }
    }
    return maxSpliteSize;
  }
    int maxUniqueSplit(string s) {
    unordered_set<string> us;
    return dfs(0,s,us);
  }
};
// @leet end