刷题笔记Day24回溯算法part03

刷题笔记Day24：回溯算法part03

题目:复原 IP 地址

93. 复原 IP 地址
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

自己的思路：想着将所有的可能性全部遍历一遍在结果收集处进行筛选（但是速度很慢）
终止条件：当递归后的子集的开始位置在字符串的结尾时候停止遍历。
单层循环逻辑：就是普通的递归逻辑，需要注意的是需要判断切割后字符串的合法性，若合法则进入递归，不合法则只是返回。

class Solution {
public:
    bool isavailable(string s_str)
    {
        if(s_str.size() != 1 && s_str[0] == '0')
        {
            return false;
        }
        if(s_str.size() > 3)
        {
            return false;
        }
        for(int i = 0; i<s_str.size();i++)
        {
            char tmp = s_str[i];
            if('0' <= tmp <= '9')
            {
                ;
            }
            else
            {
                return false;
            }
        }
        if (stoi(s_str)> 255 ||stoi(s_str)<0) {
            return false;
        }
        return true;
    }

    vector<string> tmp_s;
    vector<string> result;
    void backtracking(string s, int start_index)
    {
        if(start_index < s.size() && tmp_s.size() ==4)
        {
            return;
        }
        if(start_index == s.size() )
        {
            if (tmp_s.size() ==4) {
                string result_one;
                for(int i = 0; i<tmp_s.size()-1; i++)
                {
                    result_one = result_one + tmp_s[i] + '.';
                }
                result_one += tmp_s[tmp_s.size() -1];
                result.push_back(result_one);
            }
            return;
        }

        for(int i = start_index; i< s.size();i++)
        {
            string s_s(s.begin()+start_index,s.begin()+i + 1);
            if(isavailable(s_s))
            {
                tmp_s.push_back(s_s);
                backtracking(s,i+1);
                tmp_s.pop_back();
            }
            else
            {
                return;
            }
        }
    }
    vector<string> restoreIpAddresses(string s) {
        backtracking(s,0);
        return result;
    }
};

题目：子集

78. 子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

思路：将所有每一层的递归数据都收集起来而不是只在终止条件处收集数据

class Solution {
public:
    vector<int> tmp;
    vector<vector<int>> result = {{}};
    void backtracking(vector<int>& nums , int start_index)
    {
        if(start_index == nums.size())
        {
            return;
        }

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

题目：子集II

90.子集II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

思路：本体就是题目子集的升级版本，需要考虑去重的逻辑
去重逻辑：通过sort来对nums中的值进行排序，在同一层的for循环中增加去重逻辑，通过将此刻的值和之前的值进行对比，若相同则说明此刻所选择的值的所有组合已经被之前的值包含了，因此需要跳过。

class Solution {
public:
    vector<int> tmp;
    vector<vector<int>> result = {{}};
    void backtracking(vector<int>& nums , int start_index)
    {
        if(start_index == nums.size())
        {
            return;
        }

        for(int i = start_index; i < nums.size();i++)
        {
            if(i > start_index && nums[i] == nums[i-1])
            {
                continue;
            }
            tmp.push_back(nums[i]);
            result.push_back(tmp);
            backtracking(nums, i+1);
            tmp.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        backtracking(nums,0);
        return result;
    }
};