看完之後，腦袋對於這道題目的想法清晰很多，自己的做法比較偏向是加一個path，而卡哥則是在原字串上進行操作，但兩種方法都實現出來了，一開始主要錯誤點在終止條件的錯誤設置，判斷Valid IP 的函數處理錯誤，以及回溯操作的錯誤，這幾個錯誤點導致我的程式無法正常值行，但整體的想法是有，但實際執行上在思考上自己有很多部分需要去釐清。

78.子集

自己看到题目的第一想法

在組合以及分割的時候都是有符合某個條件才收集結果，但在這一題當中可以想像就是每個節點收集結果，並且這個是一個集合，彼此不能相互干擾，需要使用startIndex 來進行控制

90.子集II

自己看到题目的第一想法

這題的第一個想法是其實就是跟組合總和II 一樣，需要進行去重，如果用卡哥的做法used 或者是跳過重複元素都可以蠻清楚的去解決這個問題

93.复原IP地址 - 實作

思路

錯誤思路

建立一個results 以及 path 儲存結果
回溯函數
1. 傳入值 s, startIndex
2. 終止條件
  1. startIndex大於s.size
  2. 如果startIndex大於s.size 代表已經找到一組切割方案，因為startIndex可以想像成切割線，如果切割線大於等於s的大小，代表已經沒有要切割的部分了
  3. 並且因為在單遞迴都有判斷是否為有效IP，所以如果到達終止條件的path裡的子字串都是有效IP
3. 單遞迴
  1. i = startIndex; i < s.size() + 3 ; i++ 每個子字符串最多三個數
  2. 獲取startIndex 到 i 之間的區間→ 代表著s中的子串
  3. 判斷startIndex 到 i之間是否為有效IP
    1. 如果是，則將這個子串存入path
    2. 不是則跳過這次迴圈
判斷有效IP函數
1. path大小為一 path[0] 可以是0，path大小大於1 path[0] ≠ 0
2. ip 長度需介於 0~255之間
主函式
1. 傳入s以及0
2. return results.

錯誤點:

終止條件設置錯誤，導致遞迴並未在深度為四的時候停止，而是繼續執行，新增pointSum來記錄目前的深度(已分割幾次)，並對最後的字串進行判斷與處理
for迴圈的終止條件設錯，有可能會讓startIndex超出i的範圍
回溯操作錯誤，導致path字串沒有正常回溯，改為紀錄原本的size，對path字串進行回溯操作
判斷Valid IP 函數中
1. 未Filter s.size > 3 && < 1 的狀況
2. 計算數值的部分，邊界條件設錯，應該是i ≥ 0 而不是 i > 0 這樣會少計算一次，導致錯誤結果

正確思路

建立一個results 以及 path 儲存結果
回溯函數
1. 傳入值 s, startIndex, pointSum
2. 終止條件
  1. pointSum == 3
  2. 如果pointSum == 3代表已經切割到第三次，代表已經沒有要切割的部分了
  3. 判斷最後的子字串是否Valid，如果有效則將結果放入results當中
3. 單遞迴
  1. i = startIndex; i < s.size() ; i++
  2. 獲取startIndex 到 i 之間的區間→ 代表著s中的子串
  3. 紀錄目前的path大小 → 供字串回溯操作使用
  4. 判斷startIndex 到 i之間是否為有效IP
    1. 如果是，則將這個子串存入path，並加入’.’
    2. 不是則跳過這次迴圈
  5. 遞迴操作 backtracking(s, i + 1, pointSum + 1)
  6. 回溯操作 path.resize(oldSize)
判斷有效IP函數
1. path大小為一 path[0] 可以是0，path大小大於1 path[0] ≠ 0
2. path長度需介於 1 ~ 3 之
3. ip 數值需介於 0~255之間
主函式
1. 傳入s, 0, 0
2. return results.

不使用path的思路

建立一個results 儲存結果
回溯函數
1. 傳入值 s, startIndex, pointSum
2. 終止條件
  1. pointSum == 3
  2. 如果pointSum == 3代表已經切割到第三次，代表已經沒有要切割的部分了
  3. 判斷最後的子字串是否Valid，如果有效則將結果放入results當中
3. 單遞迴
  1. i = startIndex; i < s.size() ; i++
  2. 判斷startIndex 到 i之間是否為有效IP
    1. 如果是
      1. 在切割點加入一個逗號
      2. 遞迴操作
      3. 回溯刪除逗號
    2. 不是則結束本層循環，因為假設當前的切割是 01.0.0.01 就算第一個切割點在往後仍然都不是合法的IP 數值。 → 剪枝操作
  3. 遞迴操作 backtracking(s, i + 1, pointSum + 1)
  4. 回溯操作 path.resize(oldSize)
判斷有效IP函數
1. path大小為一 path[0] 可以是0，path大小大於1 path[0] ≠ 0
2. path長度需介於 1 ~ 3 之
3. ip 數值需介於 0~255之間
4. 非數字字符不合法
主函式
1. 傳入s, 0, 0
2. return results.

Code

錯誤思路

class Solution {
public:
    vector<string> results;
    string path;
    void backtracking(const string& s, int startIndex) {
        if(startIndex >= s.size()) {
            results.push_back(path);
            return;
        }

        for(int i = startIndex; i < startIndex + 3; i++) {
            string str = s.substr(startIndex, i - startIndex + 1);
            if(isValidIP(str)) {
                path += str;
                path += '.';
            } else {
                continue; 
            }
            backtracking(s, i + 1);
            path.pop_back();
        }
    }
     bool isValidIP(const string& s) {
        int count = 1;
        int sum = 0;
        if(s.size() != 1 && (s[0] - '0') == 0) return false;
        for (int i = s.size() - 1; i > 0; i--) {
            sum += (s[i] - '0') * count;
            count *= 10;
        }
        if(sum > 255 || sum < 0) return false;
        return true;
    }
    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0);
        return results;
    }
};

正確思路

class Solution {
public:
    vector<string> results;
    string path;
    void backtracking(const string& s, int startIndex, int pointSum) {
        if(pointSum == 3) {
            string str = s.substr(startIndex, s.size());
            if(isValidIP(str)) {
                results.push_back(path + str);
            }
            return;
        }

        for(int i = startIndex; i < s.size(); i++) {
            string str = s.substr(startIndex, i - startIndex + 1);
            int oldSize = path.size();
            if(isValidIP(str)) {
                path += str;
                path += '.';
            } else {
                continue; 
            }
            backtracking(s, i + 1, pointSum + 1);
            path.resize(oldSize);
        }
    }
     bool isValidIP(const string& s) {
			  int count = 1;
        int sum = 0;
        if(s.size() != 1 && (s[0] - '0') == 0 ) return false;
        if(s.size() > 3 || s.size() < 1) return false;
				for (int i = s.size() - 1; i >= 0; i--) {
            sum += (s[i] - '0') * count;
            count *= 10;
        }
        for (int i = 0; i < s.size(); i++) {
            sum = (s[i] - '0') + sum * 10;
        }
        if(sum > 255) return false;
        return true;
    }
    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0, 0);
        return results;
    }
};

不使用path的思路(代碼來源代碼隨想錄)

class Solution {
private:
    vector<string> result;// 记录结果
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                backtracking(s, i + 2, pointNum + 1);   // 插入逗点之后下一个子串的起始位置为i+2
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else break; // 不合法，直接结束本层循环
        }
    }
    // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) { // 0开头的数字不合法
                return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
                return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255) { // 如果大于255了不合法
                return false;
            }
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }
};

78.子集 - 實作

思路

建立一個path 以及 results 收集結果
回溯函數需傳入 nums 以及 startIndex
終止條件 if startIndex >= nums.size()
單遞迴
1. I = startIndex I < nums.size() I ++
2. path.push_back(nums[i])
3. results.push_back(path)
4. backtracking (nums, i + 1)
5. path.pop_back()
return

Code

class Solution {
public:
    vector<vector<int>> results;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if(startIndex >= nums.size()) return;

        for(int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            results.push_back(path);
            backtracking(nums, i + 1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        results.push_back(path);
        backtracking(nums, 0);
        return results;
    }
};

90.子集II - 實作

思路

Used 錯誤思路

建立一個path, results 數組儲存結果
回溯函數
1. 傳入值 nums, startIndex, used
2. 終止條件
  1. if startIndex ≥ nums.size()
3. 單遞迴
  1. I = startIndex i < nums.size I ++
  2. if( i > 0 && nums[i] == nums[i-1] && used[i - 1] == false)
    1. continue;
  3. else
    1. path.push_back(nums[i])
    2. results.push_back(path)
  4. used[i] == true
  5. backtracking(nums, i + 1, used)
  6. used[i] == false
  7. path.pop_back()
4. return
主函式
1. created used
2. backtracking
3. Return results

錯誤點: 忘記排序

Used 正確思路

建立一個path, results 數組儲存結果
回溯函數
1. 傳入值 nums, startIndex, used
2. 終止條件
  1. if startIndex ≥ nums.size()
3. 單遞迴
  1. I = startIndex i < nums.size I ++
  2. if( i > 0 && nums[i] == nums[i-1] && used[i - 1] == false)
    1. continue;
  3. else
    1. path.push_back(nums[i])
    2. results.push_back(path)
  4. used[i] == true
  5. backtracking(nums, i + 1, used)
  6. used[i] == false
  7. path.pop_back()
4. return
主函式
1. created used
2. sort nums;
3. backtracking
4. Return results

使用i 跳過相同元素思路

建立一個path, results 數組儲存結果
回溯函數
1. 傳入值 nums, startIndex, used
2. 終止條件
  1. if startIndex ≥ nums.size()
3. 單遞迴
  1. I = startIndex i < nums.size I ++
  2. path.push_back(nums[i])
  3. results.push_back(path)
  4. backtracking(nums, i + 1, used)
  5. path.pop_back()
  6. while ( i + 1 < nums.size() && nums[i] == nums[i+1] ) i ++
4. return
主函式
1. sort nums;
2. backtracking
3. Return results

Code

Used 錯誤思路

class Solution {
public:
    vector<vector<int>> results;
    vector<int> path;
    
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        if(startIndex >= nums.size()) return;

        for(int i = startIndex; i < nums.size(); i++) {
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
            else {
                path.push_back(nums[i]);
                results.push_back(path);
            }
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        results.push_back(path);
        backtracking(nums, 0, used);
        return results;      
    }
};

Used 正確思路

class Solution {
public:
    vector<vector<int>> results;
    vector<int> path;
    
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        if(startIndex >= nums.size()) return;

        for(int i = startIndex; i < nums.size(); i++) {
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
            else {
                path.push_back(nums[i]);
                results.push_back(path);
            }
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        results.push_back(path);
        backtracking(nums, 0, used);
        return results;      
    }
};

使用i 跳過相同元素思路

class Solution {
public:
    vector<vector<int>> results;
    vector<int> path;
    
    void backtracking(vector<int>& nums, int startIndex) {
        if(startIndex >= nums.size()) return;

        for(int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            results.push_back(path);
            backtracking(nums, i + 1);
            path.pop_back();
            while(i + 1 < nums.size() && nums[i] == nums[i + 1]) i++;
        }
        return;
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        results.push_back(path);
        backtracking(nums, 0);
        return results;      
    }
};