day28 第七章 回溯算法

第七章 回溯算法

93.复原IP地址
78.子集
90.子集II

class Solution {
    vector<string> result;
    string path;
    int dotcnt;
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        path.clear();
        dotcnt = 0;
        if (s.length() < 4 || s.length() > 12) return result;
        backtracking(s, 0);
        return result;
    }
    void backtracking(string& s, unsigned int startIndex) {
        // cout << dotcnt << " " << path << endl;
        if (dotcnt == 4) {
            if (path.size() == s.size() + 4) {
                path.pop_back();
                result.push_back(path);
                path.push_back('.');
            }
            return;
        }
        string substr;
        for (int i = startIndex; i < startIndex + 3; ++ i) {
            substr.push_back(s[i]);
            path.push_back(s[i]);
            pair<long long, bool> ret = isvalid(substr);
            if (ret.first > 255 || ret.second == true) break;
            path.push_back('.');
            ++ dotcnt;
            backtracking(s, i + 1);
            path.pop_back();
            -- dotcnt;
        }
        for (int j = 0; j < substr.size(); ++ j) {
            path.pop_back();
        }
    }
    pair<long long, bool> isvalid(string substr) {
        pair<long long, bool> ret;
        // 判断是否有前导0
        if (substr.size() > 1 && substr[0] == '0') ret.second = true;
        // 判断值范围
        long long sum = 0;
        for (auto ch : substr) {
            sum = sum * 10 + (ch - '0');
        }
        ret.first = sum;
        return ret;
    }
};




class Solution {
    vector<vector<int>> result;
    vector<int> subset;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        subset.clear();
        backtracking(nums, 0);
        return result;
    }
    void backtracking(vector<int>& nums, int startIndex) {
        if (startIndex == nums.size()) {
            result.push_back(subset);
            return;
        }
        // 1 该索引元素不在集合中
        backtracking(nums, startIndex + 1);


        // 2 在集合中
        subset.push_back(nums[startIndex]);
        backtracking(nums, startIndex + 1);
        subset.pop_back();
    }
};






// 递归两种逻辑，一种是一层递归表示要么该元素存在，要么不存在
//                             二种是一层表示将所有元素都试一试。

class Solution {
    vector<vector<int>> result;
    vector<int> subset;
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        subset.clear();
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return result;
    }
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(subset);
        for (int i = startIndex; i < nums.size(); ++ i) {
            if (i > startIndex && nums[i] == nums[i - 1]) {
                continue;
            }
            subset.push_back(nums[i]);
            backtracking(nums, i + 1);
            subset.pop_back();
        }
    }
};

class Solution {
    vector<vector<int>> result;
    vector<int> subset;
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        subset.clear();
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return result;
    }
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(subset);
        for (int i = startIndex; i < nums.size(); ++ i) {
            if (i > startIndex && nums[i] == nums[i - 1]) {
                continue;
            }
            subset.push_back(nums[i]);
            backtracking(nums, i + 1);
            subset.pop_back();
        }
    }
};