力扣算法 39. 组合总和 40.组合总和II 131.分割回文串 78.子集

最新推荐文章于 2024-09-13 16:27:15 发布

菜菜要要努力

最新推荐文章于 2024-09-13 16:27:15 发布

阅读量89

点赞数

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/m0_51982291/article/details/129546724

版权

学习内容

力扣算法

39. 组合总和

40.组合总和II

131.分割回文串

78.子集

具体内容

39. 组合总和

给你一个无重复元素的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有不同组合，并以列表形式返回。你可以按任意顺序返回这些组合。

candidates 中的同一个数字可以无限制重复被选取。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3
可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。仅有这两种组合。

示例 2：

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

示例 3：

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

提示：

1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40

做题思路

该题的解题思路与力扣算法77相似，不同点在于该题满足结果集的自己元素可以重复取值

解题

class Solution {
	//保存满足条件的结果集
	List<List<Integer>> result = new ArrayList<>();
	//保存满足条件的结果
	LinkedList<Integer> path = new LinkedList<>();
	public List<List<Integer>> combinationSum(int[] candidates, int target) {
		//为后面的剪枝优化做准备
		Arrays.sort(candidates);
		backtracking(candidates,target,0,0);
		return result;
	}
	public void backtracking(int[] candidates, int target,int sum,int index){
		//终止条件
		if(sum == target){
			result.add(new ArrayList<>(path));
			return;
		}
		for(int i = index;i < candidates.length;i++){
			//if(sum < candidates[i]){
				//continue;
			//}
			//剪枝优化
			if(sum + candidates[i] > target){
				//直接结束该递归
				break;
			}
			//处理节点
			path.add(candidates[i]);
			sum+=candidates[i];
			//递归
			backtracking(candidates,target,sum,i);
			//回溯
			sum -= candidates[i];
			path.removeLast();
		}
	}
}

解答代码存在的疑问

1、为什么要排序？
因为后面是通过判断目前的sum值与当前的candidates[i]值相加是否大于target来终止循环，而为了后面的数会满足此次的剪枝操作，从而完成剪枝的操作，

40.组合总和II

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

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

说明：所有数字（包括目标数）都是正整数。解集不能包含重复的组合。

加粗样式

示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:

[ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]

示例 2:
输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:

[ [1,2,2], [5] ]

做题思路

由于candidates 中的每个数字在每个组合中只能使用一次。
且解集不能包含重复的组合。因此除了对数枝进行去重，还要对数层进行去重

解题

class Solution {
  LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
    boolean[] used;
   

  public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    boolean[] used = new boolean[candidates.length];
    // 加标志数组，用来辅助判断同层节点是否已经遍历
    // Arrays.fill(used, false);
    // 为了将重复的数字都放到一起，所以先进行排序
    Arrays.sort(candidates);
    backTracking(candidates, target, 0,0,used);
    return ans;
  }

  private void backTracking(int[] candidates, int target, int startIndex,int sum,boolean[] used) {
    if (sum == target) {
      ans.add(new ArrayList(path));
    }
    for (int i = startIndex; i < candidates.length; i++) {
      if (sum + candidates[i] > target) {
        break;
      }
      // 出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
      if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
        continue;
      }
      used[i] = true;
      sum += candidates[i];
      path.add(candidates[i]);
      // 每个节点仅能选择一次，所以从下一位开始
      backTracking(candidates, target, i + 1,sum,used);
      used[i] = false;
      sum -= candidates[i];
      path.removeLast();
    }
  }
}

解答代码存在的疑问

在这里插入图片描述 1、1、为什么要数层去重，如何进行树层去重
以数组（1，1，2）为例，当遍历到第2个1时，他所得出得子集（1，2）已经被遍历第1个1时包含了，这样子集就会重复；先将数组进行排序，即相同元素会放在一起，利用标志位，若前一个标志位为不为1，则说明前一个的元素没有被使用
2、分析这一行代码的含义

if(i>0 && candidates[i]==candidates[i-1] && !flag[i-1]){continue;}

这一行代码的作用是树层去重，candidates[i]==candidates[i-1]表示当前元素和前一个元素相等，!flag[i-1]判断前一个元素是否为0，若为0，从代码上看就说明回溯过了，然后取0，即前一个元素已经被调用过，不能再使用。i是为了防止取负值，因此大于0

131.分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例: 输入: “aab” 输出: [ [“aa”,“b”], [“a”,“a”,“b”] ]

做题思路

将此题看成是组合题目，将target看成是分隔符

解题

class Solution {
	//存放结果集
	List<List<String>> result = new ArrayList<>();
	Deque<String> path = new LinkedList<>();
	
    public List<List<String>> partition(String s) {
        backtracking(s,0);
        return result;
    }
    //判断是不是回文串
    public boolean isPalindrome(String s,int start,int end){
    	for(int i = start,j = end; i < j;i++,j--){
    		if(s.charAt(i) != s.charAt(j)){
    			return false;
    		}
    	}
    	return true;
    }
	//回溯
	public void backtracking(String s,int target){
		//终止条件
		if(target >= s.length()){
		    result.add(new ArrayList(path));
            return;
		}
		for(int i = target;i < s.length();i++){
			if(isPalindrome(s,target,i)){
                String str = s.substring(target, i + 1);
                path.addLast(str);
            }else{
                continue;
            }
           backtracking(s,i+1);
           path.removeLast();
		}
    }
}

解答代码存在的疑问

在这里插入图片描述

93.复原IP地址

给定一个只包含数字的字符串，复原它并返回所有可能的 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 地址。

示例 1：

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

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "1111"
输出：["1.1.1.1"]

示例 4：

输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]

示例 5：

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

做题思路

此题与前面的题相比起来，就是要添加分割点，且分割出的字符要满足有效ip地址的条件,target即表示分割点

解题

class Solution {
	 //结果集
	 List<String> list = new ArrayList<>();
	 public List<String> restoreIpAddresses(String s) {
	 	if(s.length() > 12){
			return;
		}
		backtracking(s,0,0);
		return list;
	 }

	//判断该段是否满足ip条件
	public boolean isValid(String s,int start.int end){
		//先排除该段开始为0的结果,由于是可以存在单独0，通过判断起始位置是否为0来判断是否是单独得0
		if(s.charAt(strat) == 0 && start != end){
			return false;
		}
		 if (start > end) {
            return false;
        }
		//判断总数num是否大于255
		int num = 0;
		for(int i = start;i <= end;i++){
			if(s.charAt(i) > '9' || s.charAt(i) < '0'){
				return false;
			}
			num = num*10 +(s.charAt(i) - '0');
			if(num > 255){
				return false;
			}
		}
		return true;
	}
	
	public void backtracking(String s,int target,int pointnum){
		//终止条件，由于ip有三个逗点，即target为3终止
		if( pointnum == 3){
			//判断是否满足条件，直接在原有得基础上分割
			if (isValid(s,target,s.length()-1)) {
                list.add(s);
            }
            return;
		}
		for(int i = target;i < s.length();i++){
			if(isValid(s,target,i)){
				s=s.substring(0, i + 1) + "." + s.substring(i + 1);
				pointnum++;
				backtracking(s,i+1,pointnum);
				pointnum--;
				s = s.substring(0, i + 1) + s.substring(i + 2);// 回溯删掉逗点
            } else {
                break;   
			}
		}
		
	}
	 
}

78.子集

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

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

示例 1：

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

示例 2：

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

解题思路

与组合问题类似，唯一不同的就是不用设置终止条件，因为没有规定子集本身得长度

解题

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    public List<List<Integer>> subsets(int[] nums) {
        backtracking(nums, 0);
        return result;
    }
    public void backtracking(int[] nums,int target){
    	//result.add(path);
    	//要注意使用new ArrayList创建新的对象
    	result.add(new ArrayList<>(path));
    	if(target >=  nums.length){
    		return;
    	}
    	for(int i=target;i < nums.length;i++){
    		path.add(nums[i]);
    		backtracking(nums,i+1);
    		path.removeLast();
    	}
    }
}