当前位置：首页 > article >正文

Leetcode百题斩-回溯

article 2025/9/8 18:42:12

回溯是一个特别经典的问题，也被排在了百题斩的第一部分，那么我们接下来来过一下这个系列。

这个系列一共八道题，偶然间发现我两年前还刷到这个系列的题，回忆起来当时刚经历淘系大变动与jf出走海外事件，大量同事离职闹得人心慌心慌，可能是当时也心生担忧于是未雨绸缪了一下。

不知不觉已经过了三年安稳的日子了，生于忧患死于安乐，该努力起来了

时间有点久远，记忆逐渐忘却了，之前用c++去攻取，那么这次用java重写一轮看看感觉如何

17. Letter Combinations of a Phone Number[medium]

思路：手机9键打字，根据按得数字枚举可能打印的字母。这个就是典型的递归，记录当前递归的位数，然后每位再扩展可能组成的字符串，最终位数到达结尾时结束

class Solution {private final List<String> phoneNumberLetter = Arrays.asList("abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz");public List<String> letterCombinations(String digits) {if (Objects.equals(digits, "")) {return Collections.emptyList();}return getLetter(0, digits, "");}public List<String> getLetter(Integer pos, String digits, String currentLetter) {List<String> newLetter = new ArrayList<>();int dLen = digits.length();if (pos == dLen) {newLetter.add(currentLetter);return newLetter;}int currentDigit = digits.charAt(pos) - '2';String currentChars = phoneNumberLetter.get(currentDigit);int cLen = currentChars.length();for (int i = 0; i < cLen; i++) {String newCurrentLetter = currentLetter + currentChars.charAt(i);newLetter.addAll(getLetter(pos + 1, digits, newCurrentLetter));}return newLetter;}
}

22. Generate Parentheses[medium]

思路：括号生成，给定括号数量，枚举可能出现的情况。这种，又是个按位递归的问题，但其实这次要记录的并不是位数，记录一下剩余左右括号的数量即可，因为需要保证左括号数量一定大于右括号数量。

class Solution {public List<String> generateParenthesis(int n) {return getParenthesis(n, n, "");}private List<String> getParenthesis(int leftNum, int rightNum, String currentString) {List<String> result = new ArrayList<>();if (rightNum == 0 && leftNum == 0) {result.add(currentString);return result;}if (rightNum - 1 >= leftNum) {result.addAll(getParenthesis(leftNum, rightNum - 1, currentString + ")"));}if (leftNum > 0) {result.addAll(getParenthesis(leftNum - 1, rightNum, currentString + "("));}return result;}
}

39. Combination Sum[medium]

思路：又是求特地和问题，但这次的区别就是，集合内的元素可以重复使用，且不限制顺序。要求枚举所有可能的情况。于是再来一个递归，将所需求和的数量作为递归参数，每个数字挨个往里面加即可，最后注意一下，因为集合问题，不用考虑顺序，于是直接按顺序添加，并再加一个位置变量来记录当前添加的字符即可。

class Solution {public List<List<Integer>> combinationSum(int[] candidates, int target) {return combinationSum(candidates, target, 0);}private List<List<Integer>> combinationSum(int[] candidates, int target, int pos) {List<List<Integer>> result = new java.util.ArrayList<>();int len = candidates.length;for (int i = pos; i < len; i++) {int current = candidates[i];if (current >= target) {if (current == target) {result.add(new java.util.ArrayList<>(Collections.singletonList(current)));}continue;}combinationSum(candidates, target - current, i).forEach(list -> {list.add(current);result.add(list);});}return result;}
}

46. Permutations[medium]

思路：求全排列，这题如果用c++，可以直接用模板库，再方便不过了，但现在自己选择了用java，那就自己暴力写呗

依旧是递归位置，然后需要一个参数记录一下已经投入的变量集合，当然注意一下。由于这个变量共享，因此一定要在每轮递归结束的时候将变量清除

class Solution {public List<List<Integer>> permute(int[] nums) {return getPermutation(0, nums, new HashSet<>());}private List<List<Integer>> getPermutation(int pos, int[] nums, Set<Integer> used) {List<List<Integer>> result = new java.util.ArrayList<>();int len = nums.length;for (int i = 0; i < len; i++) {if (used.contains(i)) {continue;}used.add(i);int currentNum = nums[i];if (pos == len - 1) {List<Integer> list = new ArrayList<>();list.add(currentNum);result.add(list);used.remove(i);return result;} else {result.addAll(getPermutation(pos + 1, nums, used).stream().peek(list -> list.add(currentNum)).collect(Collectors.toList()));}used.remove(i);}return result;}
}

78. Subsets[Meduim]

思路：求集合的子集，这就是最经典的递归回溯问题了。按位回溯，每个位置回溯是否包含当前字符的两种情况

class Solution {public List<List<Integer>> subsets(int[] nums) {return getSubsets(0, nums);}private List<List<Integer>> getSubsets(int pos, int[] nums) {List<List<Integer>> result = new ArrayList<>();int len = nums.length;if (pos == len - 1) {List<Integer> list1 = new ArrayList<>();list1.add(nums[pos]);result.add(list1);List<Integer> list2 = new ArrayList<>();result.add(list2);return result;}result.addAll(getSubsets(pos + 1, nums).stream().peek(list -> list.add(nums[pos])).collect(Collectors.toList()));result.addAll(getSubsets(pos + 1, nums));return result;}
}

79. Word Search[Medium]

思路：棋盘搜索问题，二维递归回溯的经典问题，回溯四个方向即可，注意一下为了避免往回回溯形成死循环，每次回溯点需要抹掉，回溯完成后恢复即可

class Solution {public boolean exist(char[][] board, String word) {int xLen = board.length;for (int i = 0; i < xLen; i++) {int yLen = board[i].length;for (int j = 0; j < yLen; j++) {if (search(i, j, board, word, 0)) {return true;}}}return false;}private boolean search(int x, int y, char[][] board, String word, int pos) {char currentChar = board[x][y];//System.out.println(x + "*" + y + "*" + currentChar + "*" + pos);if (board[x][y] != word.charAt(pos)) {return false;}board[x][y] = 0;boolean bingo = false;if (pos == word.length() - 1) {bingo = true;} else if (x > 0 && search(x - 1, y, board, word, pos + 1)) {bingo = true;} else if (y > 0 && search(x, y - 1, board, word, pos + 1)) {bingo = true;} else if (x < board.length - 1 && search(x + 1, y, board, word, pos + 1)) {bingo = true;} else if (y < board[x].length - 1 && search(x, y + 1, board, word, pos + 1)) {bingo = true;}board[x][y] = currentChar;return bingo;}
}

131. Palindrome Partitioning[Medium]

思路：将字符串分割成多个回文子串，求所有分割方案。其实分隔子串这类问题，首先想到的就是递归回溯。按位进行回溯，从每个位置开始，先枚举添加的回文串，再递归剩余的子串。至于回文串判断，这里就采用最暴力的双指针进行判断，为了避免重复，将已经判断过的结果进行持久化记录一下。如果想优化预处理回文串，可以看之前的一篇回文串的文章，那里介绍了从立方复杂度的暴力求法到最佳常数复杂度的Manarch算法。

class Solution {private Map<String, Boolean> palindromeSet = new HashMap<>();public List<List<String>> partition(String s) {List<List<String>> result = getPartition(s, 0);result.forEach(Collections::reverse);return result;}private List<List<String>> getPartition(String s, int pos) {List<List<String>> result = new ArrayList<>();int len = s.length();if (pos == len) {List<String> endResult = new ArrayList<>();result.add(endResult);return result;}for (int i = pos; i < len; i++) {String current = s.substring(pos, i + 1);if (isPalindrome(current)) {List<List<String>> partition = getPartition(s, i + 1);for (List<String> list : partition) {list.add(current);}result.addAll(partition);}}return result;}private boolean isPalindrome(String s) {if (palindromeSet.containsKey(s)) {return palindromeSet.get(s);}int left = 0;int right = s.length() - 1;boolean palindrome = true;while (left <= right) {if (s.charAt(left) != s.charAt(right)) {palindrome = false;break;}left++;right--;}palindromeSet.put(s, palindrome);return palindrome;}
}

51. N-Queens[Hard]

思路：N皇后问题，可以算是递归回溯系列经典中的经典。给定边长为N的棋盘大小，要求所有能摆出N个不相攻击的皇后摆法（皇后可以任意横着走或者斜着走）。这题显然需要遍历每个棋格去进行递归，递归时维护已经摆上的皇后数量，所需的皇后数量，以及当前棋盘的状态。当摆上皇后时，遍历更新棋盘，标记不可继续放置棋盘的位置。由于棋盘需要反复被标记，导致复杂度变高，这里根据皇后的特性不难发现，只需要维护三个集合 $y,x+y,x-y$ ，即可分别表示皇后所在列，以及所在的两个斜线，从而避免反复标记棋盘。而针对皇后所在行，每次放置皇后时跳到下一行即可避免同行皇后。此外，由于按顺序遍历所有棋格，因此可以直接用一维字符数组代替二维棋盘，最后转换一下即可表示棋盘最终形态

class Solution {public List<List<String>> solveNQueens(int n) {char[] board = new char[n * n];for (int i = 0; i < n * n; i++) {board[i] = '.';}Set<Integer> s1 = new HashSet<>();Set<Integer> s2 = new HashSet<>();Set<Integer> s3 = new HashSet<>();return getNQueens(0, board, 0, n, s1, s2, s3);}private List<List<String>> getNQueens(int pos, char[] board, int now, int n, Set<Integer> s1,Set<Integer> s2, Set<Integer> s3) {List<List<String>> result = new ArrayList<>();if (now == n) {List<String> endResult = getResult(board, n);result.add(endResult);return result;} else if (pos >= n * n) {return Collections.emptyList();}int x = pos / n;int y = pos % n;if (!s1.contains(x + y) && !s2.contains(x - y) && !s3.contains(y)) {board[pos] = 'Q';s1.add(x + y);s2.add(x - y);s3.add(y);int nextPos = (x + 1) * n;result.addAll(getNQueens(nextPos, board, now + 1, n, s1, s2, s3));s1.remove(x + y);s2.remove(x - y);s3.remove(y);board[pos] = '.';}result.addAll(getNQueens(pos + 1, board, now, n, s1, s2, s3));return result;}private List<String> getResult(char[] board, int n) {List<String> result = new ArrayList<>();for (int i = 0; i < n; i++) {StringBuilder sb = new StringBuilder();for (int j = 0; j < n; j++) {sb.append(board[i * n + j]);}result.add(sb.toString());}return result;}
}

最终，递归回溯完结