LeetCode——回溯篇（二）

最新推荐文章于 2024-08-31 00:26:34 发布
最新推荐文章于 2024-08-31 00:26:34 发布
阅读量419 收藏
点赞数
分类专栏： 做题总结 文章标签： leetcode 算法 java backtracking 回溯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zssxcj/article/details/132542573
版权

刷题顺序及思路来源于代码随想录，网站地址：https://programmercarl.com

目录

131. 分割回文串

93. 复原 IP 地址

78. 子集

90. 子集 II

491. 递增子序列

131. 分割回文串

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

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

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author light
 * @Description 分割回文串
 * @create 2023-08-28 17:07
 */
public class PartitionTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		String s=input.nextLine();
		System.out.println(partition(s));
	}

	public static List<List<String>> res=new ArrayList<>();
	public static List<String> path=new ArrayList<>();

	public static List<List<String>> partition(String s) {
		backtracking(s,0);
		return  res;
	}

	private static void backtracking(String s, int startIndex) {
		//终止条件
		if(startIndex>=s.length()){
			//收获结果
			res.add(new ArrayList<>(path));
			return;
		}

		for (int i = startIndex; i <s.length() ; i++) {
			//判断是否回文，如果是，则加入到path中
			if(isPalindrome(s,startIndex,i)){
				String str=s.substring(startIndex,i+1);
				path.add(str);
			}else {
				continue;
			}
			backtracking(s,i+1);
			//回溯
			path.remove(path.size()-1);
		}
	}

	private static boolean isPalindrome(String s, int left, int right) {
		for (int i = left,j=right; i <j ; i++,j--) {
			if(s.charAt(i)!=s.charAt(j)){
				return false;
			}
		}
		return true;
	}
}

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 中的任何数字。你可以按 任何 顺序返回答案。

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author light
 * @Description 复原IP地址
 * @create 2023-08-28 21:21
 */
public class RestoreIpAddressesTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		String s=input.nextLine();
		System.out.println(restoreIpAddresses(s));
	}
	public static List<String> res=new ArrayList<>();
	public static List<String> restoreIpAddresses(String s) {
		if(s.length()>12){ //剪枝
			return res;
		}
		//采用StringBuilder,不用重复重复重复创建字符串
		StringBuilder sb=new StringBuilder(s);
		backtracking(sb,0,0);
		return res;
	}

	private static void backtracking(StringBuilder sb, int startIndex, int pointCount) {
		//终止条件
		if(pointCount==3){
			// 判断第四段子字符串是否合法，如果合法就放进result中
			if(isValid(sb,startIndex,sb.length()-1)){
				res.add(sb.toString());
			}
			return;
		}
		for (int i = startIndex; i < sb.length(); i++) {
			//判断字段是否合法
			if(isValid(sb,startIndex,i)){
				//如果合法添加"." sb.insert（）方法，该方法是在索引的前面添加字符串
				sb.insert(i+1,".");
				pointCount++;
				//将i+2的位置作为下一个字符串的起始位置，因为多添加了一个"."
				backtracking(sb,i+2,pointCount);
				//回溯
				sb.deleteCharAt(i+1);
				pointCount--;
			}else {
				break;
			}
		}
	}

	/*
	判断是否合法IP段：
		1.每个整数位于0到255之间组成
		2.段位以0为开头的数字不合法
		3.段位里有非正整数字符不合法
	 */
	private static boolean isValid(StringBuilder sb, int start, int end) {
		if(start>end){
			return false;
		}
		//3.段位里有非正整数字符不合法
		for (int i = start; i <=end ; i++) {
			if(sb.charAt(i)<'0'||sb.charAt(i)>'9'){
				return false;
			}
		}
		//1.每个整数位于0到255之间组成
		int num=Integer.parseInt(sb.substring(start,end+1));
		if(num<0||num>255){
			return false;
		}
		//2.段位以0为开头的数字不合法
		if(sb.charAt(start)=='0'&&start!=end){
			return false;
		}
		return true;
	}

}

78. 子集

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

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

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author light
 * @Description 子集
 *
 * (思路：如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，
 * 那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！
 *
 * 其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。
 * @create 2023-08-29 10:25
 */
public class SubsetsTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for (int i = 0; i < n; i++) {
			nums[i]=input.nextInt();
		}
		System.out.println(subsets(nums));
	}

	public static List<List<Integer>> res=new ArrayList<>();
	public static List<Integer> path=new ArrayList<>();
	public static List<List<Integer>> subsets(int[] nums) {
		backtracking(nums,0);
		return res;
	}

	private static void backtracking(int[] nums, int startIndex) {
		res.add(new ArrayList<>(path));//收集子集,要放在终止添加的上面,否则会漏掉自己
		//终止条件
		if(startIndex>=nums.length){
			return;
		}
		for (int i = startIndex; i < nums.length; i++) {
			path.add(nums[i]);
			backtracking(nums,i+1);
			//回溯
			path.remove(path.size()-1);
		}
	}
}

90. 子集 II

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

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

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @author light
 * @Description 子集II
 * @create 2023-08-29 11:03
 */
public class SubsetsWithDupTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for (int i = 0; i < n; i++) {
			nums[i]=input.nextInt();
		}
		System.out.println(subsetsWithDup(nums));
	}

	public static List<List<Integer>> res=new ArrayList<>();
	public static List<Integer> path=new ArrayList<>();

	public static List<List<Integer>> subsetsWithDup(int[] nums) {
		Arrays.sort(nums);
		int[] used=new int[nums.length];
		Arrays.fill(used,0);
		backtracking(nums,0,used);
		return res;
	}

	private static void backtracking(int[] nums, int startIndex, int[] used) {
		res.add(new ArrayList<>(path));
		//终止条件
		if(startIndex>=nums.length){
			return;
		}

		for (int i = startIndex; i < nums.length; i++) {
			if(i>0&&nums[i]==nums[i-1]&&used[i-1]==0){
				continue;
			}
			path.add(nums[i]);
			used[i]=1;
			backtracking(nums,i+1,used);
			//回溯
			path.remove(path.size()-1);
			used[i]=0;

		}

	}
}

491. 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
import java.util.*;

/**
 * @author light
 * @Description 递增子序列
 * @create 2023-08-29 15:01
 */
public class FindSubsequencesTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for (int i = 0; i < n; i++) {
			nums[i]=input.nextInt();
		}
		System.out.println(findSubsequences(nums));
	}
	public static List<List<Integer>> res=new ArrayList<>();
	public static List<Integer> path=new ArrayList<>();
	public static List<List<Integer>> findSubsequences(int[] nums) {
		backtracking(nums,0);
		return res;
	}

	private static void backtracking(int[] nums, int startIndex) {
		if(path.size()>1){
			res.add(new ArrayList<>(path));  //注意不要加return，要收集树上的所有节点
		}
		if(startIndex>=nums.length){
			return;
		}
		Set<Integer> set=new HashSet<>();//记录本层元素是否重复使用
		for (int i = startIndex; i < nums.length; i++) {
			//如果队列不为空，但要添加的元素小于path中的最后一个元素---不是递增的---不满足条件
			//或者集合中已经含有nums[i]---本层有重复元素----不满足条件
			if((!path.isEmpty()&&nums[i]<path.get(path.size()-1))||set.contains(nums[i])){
				continue;
			}
			set.add(nums[i]); //每层都创建一个---不需要回溯
			path.add(nums[i]);
			backtracking(nums,i+1);
			//回溯
			path.remove(path.size()-1);
		}

	}
}

要向着光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode——回溯
weixin_45680007的博客
02-17 203
回溯法： 第几个全排列 括号组合 下一个排列 数字组合 矩阵中对应字符串 第几个全排列： 给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。 按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下： “123” “132” “213” “231” “312” “321” 给定 n 和 k，返回第 k 个排列。 说明： 给定 n 的范围是 [1, 9]。 给定 k ...
【leetcode】回溯法总结
天蓝
03-30 1311
回溯法、backtracking、Combinations、 Combination Sum、Combination Sum II、Combination Sum III、Permutations、Permutations II、 Generate Parentheses、Subsets、Subsets II、Beautiful Arrangement
LeetCode——回溯
weixin_47156261的博客
03-17 705
组合三部曲 确定函数参数和递归终止条件 for循环遍历树的深度和宽度 回溯记得pop_back. 1. 组合 为了简单将两个vector设为全局变量 startindex要传入，不然递归时无法往下更新 递归过程中伴随回溯，path.pop_back就是在回溯过程中使用的， class Solution { public: vector<vector<int>>res; vector<int>path; void backtracking(int n,int
Leetcode——回溯法专题
qq_42265220的博客
11-28 2643
学习目标： 学习回溯法 做Leetcode上的回溯法的题目，写学习笔记。 学习内容： Leetcode回溯法题目汇总： 题型一：排列、组合、子集相关问题 提示：这部分练习可以帮助我们熟悉「回溯算法」的一些概念和通用的解题思路。解题的步骤是：先画图，再编码。去思考可以剪枝的条件， 为什么有的时候用 used 数组，有的时候设置搜索起点 begin 变量，理解状态变量设计的想法。 全排列（中等） 全排列 II（中等）：思考为什么造成了重复，如何在搜索之前就判断这一支会产生重复； 组合总和（中等） 组合总和
LeetCode——回溯算法(Java)
jhin_lx的博客
03-05 733
记录一下自己刷题的历程以及代码。写题过程中参考了代码随想录的刷题路线。会附上一些个人的思路，如果有错误，可以在评论区提醒一下。涉及：深浅拷贝、递归public 主方法(参数) {//把递归参数传入递归函数return ans;if(达到终止条件) {//存放结果return;for(循环调用后续的递归)
leetcode——回溯算法题目合集
盛夏与微风
05-17 1162
回溯算法简介 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法...
Leetcode——回溯法 palindrome-partitioning
小张的记录
07-03 194
palindrome-partitioning 题目描述： Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s. For example, given s =“aab”, R...
leetcode——-解数独(回溯法)
01-20
重要：对于回溯法，一定会有个[规则]，这个[规则]将会决定是否回退，所以当我们在使用回溯法时，一定要留意能否构建[规则]。 如这一题，在数独中，规则就是： 1. 在同一列和同一行中，不能出现一样的数字。 2. 在同...
Leetcode——中级部分——回溯算法部分——Python实现
dta0502的博客
07-15 2863
电话号码的字母组合 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 391
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4217
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
leetcode3 无重复字符的最长子串
weixin_44554979的博客
08-30 132
除了每次有重复的要更新 ，如果abc这种，本身就不会重复，那maxLength就永远不会更新了。比如 abccfga, 最后的a其实是没有重复的，因为在处理cc重复的时候abc都已经舍弃了。left跳转位置对了，但是left之前的在map里面的也应该清空啊。对于 abcc,应该直接加3，所以需要记录位置。left不应该是+1，对于abca，是+1。
leetcode_128_最长连续序列解析
shulu的专栏
08-29 996
如何确定一个数是连续序列的起点？如何跟踪和更新最长序列的长度？如何高效地扩展连续序列？
力扣1.两数之和（哈希表）
2401_83010439的博客
08-30 339
如果学了几个月算法力扣第一题还用暴力解法就要反思一下了。
Leetcode 22. 括号生成 回溯 C++实现
半跨考本科生的代码日常
08-28 559
代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且。
【0-1背包变种】力扣2787. 将一个数字表示成幂的和的方案数
最新发布
sjsjs11的博客
08-31 204
0-1背包问题的变种，首先我们定义一个一维数组f，f[s]表示可以用不同整数的 x 次幂来表示 s 的所有组合方式的数量。这个公式的意思是：当前目标数 s 的组合方式 f[s] 应该包括所有能组合成 s-v 的组合方式 f[s-v]，因为你可以通过加上 v 来实现 s。最后返回 f[n]，它表示用 x 次幂的整数来组合成 n 的所有不同方案的数量。比方说，n = 160 且 x = 3 ，一个表示 n 的方法是 n = 23 + 33 + 53。输入：n = 10, x = 2。
leetcode 142.环形链表II
m0_73917165的博客
08-28 478
其实设成<Integer,Integer>也是可以的，但是我们需要首先判断出来链表的长度，在进行判断环的入口的时候需要额外判断是否遍历了比链表长度还长的路程，这样才能判断出来。注意：只要不把哈希表的两个参数设为<Integer，Integer>，而是把哈希表两个参数设为<ListNode,Integer>就行，因为如果你那每一个结点的元素值作为Key，那么这个时候当你判断环的入口时就会出现明明不是出口，但是落在一个值相同的节点上。首先用快慢指针一个走一个结点，一个走两个结点，判断这个链表有无环？
力扣8.27
qq_40052678的博客
08-27 525
乍一看，这道题和上面那题思路一样，但稍微分析一下就可以知道，普通的bfs肯定会超时，所以需要采用双向广搜，但本题我才用的是另一种做法。这道题的字符串间的转换关系可以看作顶点之间连边，因此可以考虑建图然后跑最短路。的所有点，然后向其他所有点连边，但这样显然会超时，因此考虑别的建图方法。等，这样就可以通过建虚拟点大大降低建图复杂度，唯一需要注意的是，在最终计算答案时，由于我们时通过。一次基因变化就意味着这个基因序列中的一个字符发生了变化。，然后建图，最暴力的建图方法是遍历。，花费多了一倍，需要。
LeetCode面试题Day19|LC104 二叉树的最大深度
m0_74174715的博客
08-28 329
二叉树的深度与判断二叉树的相同
代码随想录：回溯算法与背包问题解析
此外，文档中还提到了GitHub上的一个项目——'leetcode-master'，这是一个与LeetCode相关的开源项目，可能包含了各种LeetCode问题的解决方案，包括回溯算法和背包问题的实现。该项目拥有40w+的star，显示了其广泛的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值