力扣第23天----第93题、第40题、第131题 - 副本

力扣第23天----第93题、第78题、第90题

一、第93题–复原IP地址

​ 这道题，挺费劲。回溯的思路，跟上一题的分割的思路挺像。不断地分割子区间，碰到不满足的就回溯。挺麻烦的，加入了字符串判断。

class Solution {
public:
    vector<string> result;

    bool isvalid(string s, int start, int end){      //为适应substr，采取左闭右开
        string sub = s.substr(start, end - start);

        if (sub.size() > 1 && sub[0] == '0') return false;
        int temp = atoi(sub.c_str());   
        
        if(temp <0 || temp >255) return false;
        else{
            return true;
        } 
    }

    void backingtrace(string s, int startindex, int num){
        if (num == 3){
            if(isvalid(s, startindex, s.size() ) ) {
                cout << s <<" " << s.substr(startindex, s.size() - startindex) <<endl;
                result.push_back(s);
            }
            return;
        }
        for (int i = startindex; i < s.size()-1; i++){     
            if (isvalid(s, startindex, i+1)){
                num++;
                s.insert( i+1, ".");
                backingtrace(s, i+2, num);
                num--;
                s.erase(i+1, 1);
            }
            else break;
        }
    }

    vector<string> restoreIpAddresses(string s) {
        backingtrace(s, 0, 0);
        return result;
    }
};

二、第78题–子集

​ 这题，还行。就是要分析出，搜集子树上每个节点对应的路径，而不只是叶子节点的路径。然后，再把每个节点代表的路径，加入到result里。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backingtrace(vector<int>& nums, int startindex){
        if (startindex >= nums.size()) return;
        for(int i = startindex; i < nums.size(); i++){
            path.push_back(nums[i]);
            result.push_back(path);
            backingtrace(nums, i+1);
            path.pop_back();
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        result.push_back(path);
        backingtrace(nums, 0);
        return result;
    }
};

三、第90题–子集II

​ 第78题、第40题的结合。知识点上，没有新的。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    
    void backingtrace(vector<int>& nums, int startindex, vector<bool>& used){
        result.push_back(path);
        for (int i = startindex; i < nums.size(); i++){
            if (i>0 && nums[i-1] == nums[i] && used[i-1] == false) continue;
            path.push_back(nums[i]);
            used[i] = true;
            backingtrace(nums, i+1, used);
            path.pop_back();
            used[i] = false;
        }
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backingtrace(nums, 0, used);
        return result;
    }
};