算法学习——LeetCode力扣回溯篇2（40. 组合总和 II、131. 分割回文串、93. 复原 IP 地址、78. 子集、90. 子集 II）

拉依达的嵌入式小屋

已于 2024-03-31 18:44:18 修改

阅读量834

点赞数 17

分类专栏： LeetCode算法学习文章标签：算法学习 leetcode c++ c语言

于 2024-02-14 22:11:53 首次发布

本文链接：https://blog.csdn.net/qq_44814825/article/details/136114462

版权

LeetCode算法学习专栏收录该内容

54 篇文章 1 订阅

订阅专栏

算法学习——LeetCode力扣回溯篇2

在这里插入图片描述

40. 组合总和 II

40. 组合总和 II - 力扣（LeetCode）

描述

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。

示例

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

代码解析

和39的区别是不能重复使用元素

回溯（无去重，超时）

无去重，只能在最后加入时候find查找是否存在一样，再加入

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtarcking(vector<int>& candidates, int target , int sum ,int indnx)
    {
        if(sum > target)return;
        if(sum == target)
        {
            auto it = find(result.begin(),result.end(),path);
            if(it == result.end() ) result.push_back(path);
            return;
        }

        for(int i=indnx ; i < candidates.size() && sum + candidates[i] <= target ; i++)
        {
            path.push_back(candidates[i]);
            backtarcking(candidates,target,sum+candidates[i],i+1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtarcking(candidates,target,0,0);
        return result;
    }
};

回溯去重

在这里插入图片描述
去重：在同一层上，值一样的元素只能用一次。同一枝上可以多次用

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtarcking(vector<int>& candidates, int target , int sum ,int indnx)
    {
        if(sum > target)return;
        if(sum == target)
        {
            result.push_back(path);
            return;
        }

        for(int i=indnx ; i < candidates.size() && sum + candidates[i] <= target ; i++)
        {
        	//发现一样的元素这一层已经用过了，直接跳过这次
            if(i > indnx && candidates[i] == candidates[i-1]) continue;

            path.push_back(candidates[i]);
            backtarcking(candidates,target,sum+candidates[i],i+1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        backtarcking(candidates,target,0,0);
        return result;
    }
};

131. 分割回文串

131. 分割回文串 - 力扣（LeetCode）

描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。

回文串是正着读和反着读都一样的字符串。

示例

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

示例 2：

输入：s = “a”
输出：[[“a”]]

提示

1 <= s.length <= 16
s 仅由小写英文字母组成

代码解析

class Solution {
public:
    vector<vector<string>> result;
   //判断字串是否是回文串
    bool check(const string &s)
    {
        for(int i=0 ; i<s.size()/2 ; i++)
        {
            if(s[i] != s[s.size()- 1 -i]) return false;
        }
        return true;
    }
    void backtracking(string s , int indnx  ,vector<string> &path)
    {
    	//当循环指针大于等于最大值的时候，认为分割出一种结果
        if(indnx >= s.size())
        {
            result.push_back(path);
            return;
        }
		//循环字符串长度，从index当前的运行指针开始切割回文串
        for(int i = indnx ; i<s.size() ;i++ )
        {
            string tmp;
            //切割字串，字串是indnx到i之间。
            for(int j = indnx ; j <= i ;j++)
            {
                tmp += s[j];
            }
            // cout<<tmp<<endl;
            //检验字串是否为回文串，是回文串压入路径，不是i+1，进行下一个长度加1的字串
            if(check(tmp)==1)   path.push_back(tmp);
            else continue;
            //如果当前字串是回文串，递归indnx加1
            backtracking(s,i+1,path);
            //回溯，弹出上一个字串
            path.pop_back();
        }
        return;
    }
    vector<vector<string>> partition(string s) {
        if(s.size()==0) return result;
        vector<string> path;
        backtracking(s,0,path);
        return result;
    }
};

93. 复原 IP 地址

93. 复原 IP 地址 - 力扣（LeetCode）

描述

有效 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”]

示例 2：

输入：s = “0000”
输出：[“0.0.0.0”]

示例 3：

输入：s = “101023”
输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]

提示

1 <= s.length <= 20
s 仅由数字组成

代码解析

class Solution {
public:
    vector<string> result;
    vector<string> path;
    //判断是合法IP
    bool cheak(string &s)
    {
        if(s.size()==0)return false;
        if(s.size() > 1 && s[0]=='0') return false;
        if (stoi(s) > 255) return false;
        return true;
    }
    void back_tracking(string &s , int indnx )
    {
    	//IP最大短是4
        if(path.size() > 4)  return;
        //循环指针大于等于长度，并且IP段为四段。合法IP
        if(indnx >= s.size() && path.size()==4)
        {
            string tmp;
            for(int i=0 ;i< path.size()-1 ;i++)
            {
                tmp += path[i];
                tmp += '.';
            }
            tmp += path[path.size()-1];
            result.push_back(tmp);
            return;
        }
		//循环输入字符串，从index开始截取IP段
        for(int i=indnx ; i<s.size() ;i++)
        {
            string tmp;
            //截取一个IP段，但是不超过3位
            for(int j = indnx ; j<=i  &&  (j-indnx)<=3 ;j++)
            {
                tmp += s[j];
            }
			//检测是否为合法段，合法压入路径，不合法跳过该段
            if(cheak(tmp)==1) path.push_back(tmp);
            else continue;
			//递归
            back_tracking(s,i+1);
            //回溯
            path.pop_back();

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

78. 子集

78. 子集 - 力扣（LeetCode）

描述

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

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

示例

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示

1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素互不相同

代码解析

在这里插入图片描述
与中序遍历N叉树非常的类似
每一个子集就是一个节点，遍历所有的节点

回溯遍历法（不要简单问题复杂化）

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums , int indnx  )
    {
    	//每一个节点都加入，无须判断节点
        result.push_back(path);
        //如果遍历指针大于等于最深处，就返回
        if(indnx >= nums.size()) return;
      	//横向循环
        for(int i=indnx ; i < nums.size() ; i++ )
        {
        	//新值压入
            path.push_back(nums[i]);
            backtracking(nums,i+1);//递归
            path.pop_back();//回溯
        }
        return;
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

90. 子集 II

90. 子集 II - 力扣（LeetCode）

描述

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

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

示例

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示

1 <= nums.length <= 10
-10 <= nums[i] <= 10

代码解析

在这里插入图片描述

去重分为层次去重和树枝去重

层次去重
是一个元素只能用一次（一样的两个可以用两次，【1，2，2】两个2各自可用一次）。
if (i > indnx && nums[i] == nums[i - 1] ) continue; 当前的和上一个相同就跳过
树枝去重
是数值一样的元素只能用一个，（一样的两个元素也只能用一次。【1，2，2】两个2只能用一个2）
回溯去重

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    int pre;
    void backtracking(vector<int>& nums , int indnx)
    {
      
        result.push_back(path);
       
        if(indnx >= nums.size())return;

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

拉依达的嵌入式小屋

关注

17
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法学习——LeetCode力扣回溯篇2（40. 组合总和 II、131. 分割回文串、93. 复原 IP 地址、78. 子集、90. 子集 II）

算法学习——LeetCode力扣回溯篇2（40. 组合总和 II、131. 分割回文串、93. 复原 IP 地址、78. 子集、90. 子集 II）
复制链接

扫一扫