回溯——算法

一、算法

1. 22. 括号生成

问题

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例2：

输入：n = 1
输出：["()"]

提示：

1 <= n <= 8

代码

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> result = new ArrayList<>();
        backtracking(n, result, 0, 0, "");
        return result;
    }
    private static void backtracking(int n, List<String> result, int left, int right, String str) {
      if(right > left) {
         return;
      }
      if(left == right && right == n) {
         result.add(str);
         return;
      }
      if(left < n) {
         backtracking(n, result, left + 1, right, str + "(");
      }
      if(right < left) {
         backtracking(n, result, left, right + 1, str + ")");
      }
   }
}

2. 77. 组合

问题

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例2：

输入：n = 1, k = 1
输出：[[1]]

提示：

1 <= n <= 20
1 <= k <= n

代码

class Solution {
    private List<List<Integer>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);
        return result;
    }

    private void backtracking(int n, int k, int startIndex) {
        // 终止条件
        if(path.size() == k) {
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i <= n; i++) {
            path.add(i);
            backtracking(n, k, i + 1); // 遍历 下一个 纵向 元素
            path.remove(path.size() - 1); // 遍历下一个 横向 元素(言外之意就是纵向元素已经遍历完回溯了，需要移除)
        }
    }

}

剪枝优化

搜索起点的上界 + 接下来要选择的元素个数 - 1 = n
其中，接下来要选择的元素个数 = k - path.size()，整理得到：

搜索起点的上界 = n - (k - path.size()) + 1
所以，我们的剪枝过程就是：把 i <= n 改成 i <= n - (k - path.size()) + 1 ：

for(int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            path.add(i);
            backtracking(n, k, i + 1); // 遍历 下一个 纵向 元素
            path.remove(path.size() - 1); // 遍历下一个 横向 元素
        }

3. 216. 组合总和 III

问题

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字最多使用一次
返回所有可能的有效组合的列表。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例1：

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例2：

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例3：

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

2 <= k <= 9
1 <= n <= 60

代码

class Solution {
    private List<Integer> path = new ArrayList<>();
    private List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k, n, 1, 0);
        return result;
    }
    private void backtracking(int k, int n, int startIndex, int sum) {
        if(path.size() == k) {
            if(sum == n) {
                result.add(new ArrayList<>(path));
                return;
            }
        }
        for(int i = startIndex; i <= 9; i++) {
            sum += i;
            path.add(i);
            backtracking(k, n, i + 1, sum);
            sum -= i;
            path.remove(path.size() - 1);

        }
    }
}

剪枝优化：

if(sum > n) {
	return;
}
if(path.size() == k) {
    if(sum == n) {
        result.add(new ArrayList<>(path));
        return;
    }
}

4. 17. 电话号码的字母组合

问题

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例2：

输入：digits = ""
输出：[]

示例3：

输入：digits = "2"
输出：["a","b","c"]

提示：

0 <= digits.length <= 4
digits[i] 是范围 ['2', '9'] 的一个数字。

代码

class Solution {
    private final String[] letterMap = {
        "",       // 0
        "",       // 1
        "abc",    // 2
        "def",    // 3
        "ghi",    // 4
        "jkl",    // 5
        "mno",    // 6
        "pqrs",   // 7
        "tuv",    // 8
        "wxyz"    // 9
    };
    private List<String> result = new ArrayList<>();
    public List<String> letterCombinations(String digits) {
        if("".equals(digits)) {
            return result;
        }
        backtracking(digits, 0, new StringBuilder());
        return result;
    }

    private void backtracking(String digits, int index, StringBuilder subString) {
        if(index == digits.length()) {
            result.add(subString.toString());
            return;
        }
        int digit = digits.charAt(index) - '0';
        String letters = letterMap[digit];
        for(int i = 0; i < letters.length(); i++) {
            subString.append(letters.charAt(i));
            backtracking(digits, index + 1, subString);
            subString.delete(subString.length() - 1, subString.length());
        }
    }
}

5. 39. 组合总和树枝剪枝或for循环剪枝

问题

给你一个无重复元素的整数数组 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
输出: []

代码

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(candiates);
        backtracking(result, new ArrayList<>(), candidates, target, 0, 0);
        return result;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] candidates, int target, int startIndex, int sum) {
        if(sum > target) {
            return;
        }
        if(sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i < candidates.length; i++) {
            sum += candidates[i];
            path.add(candidates[i]);
            backtracking(res, path, candidates, target, i, sum);
            sum -= candidates[i];
            path.remove(path.size() - 1);
        }
    }
}

剪枝优化

/*
if(sum > target) {
    return;
}
*/

for(int i = startIndex; i < candidates.length && sum + candidates[i] <= target; i++) {
    sum += candidates[i];
    path.add(candidates[i]);
    backtracking(res, path, candidates, target, i, sum);
    sum -= candidates[i];
    path.remove(path.size() - 1);
}

6. 40. 组合总和 II 排序树层去重

问题

给定一个候选人编号的集合 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]
]

代码

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backtracking(candidates, target, res, new ArrayList<Integer>(), 0, new boolean[candidates.length], 0);
        return res;
    }

    private void backtracking(int[] candidates, int target, List<List<Integer>> res,  List<Integer> path, int startIndex, boolean[] used, int sum) {
        if(sum > target) {
			return;
        }
        if(sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i <  candidates.length; i++) {
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.add(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, res, path, i + 1, used, sum + candidates[i]);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

剪枝优化

/*
if(sum > target) {
    return;
}
*/
for(int i = startIndex; i <  candidates.length && sum + candidates[i] <= target; i++) {
    
}

另一种代码

使用 i > startIndex 巧妙设计成深度可重复数字，横向不允许重复数字

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backtracking(candidates, target, res, new ArrayList<Integer>(), 0, 0);
        return res;
    }

    private void backtracking(int[] candidates, int target, List<List<Integer>> res,  List<Integer> path, int startIndex, int sum) {
        if(sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i <  candidates.length && sum + candidates[i] <= target; i++) {
            if(i > startIndex && candidates[i] == candidates[i - 1]) {
                continue;
            }
            path.add(candidates[i]);
            backtracking(candidates, target, res, path, i + 1, sum + candidates[i]);
            path.remove(path.size() - 1);
        }
    }
}

7. 131. 分割回文串判断剪枝

问题

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

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

示例1：

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

示例2：

输入：s = "a"
输出：[["a"]]

提示：

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

代码

class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>();
        backtracking(res, new ArrayList<String>(), s, 0);
        return res;
    }

    private void backtracking(List<List<String>> res, List<String> path, String s, int startIndex) {
        if(startIndex == s.length()) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i < s.length(); i++) {       
            if(isPartition(s, startIndex, i)) {
                String substring = s.substring(startIndex, i + 1);
                path.add(substring);
            } else {
                continue;
            }
            backtracking(res, path, s, i + 1);
            path.remove(path.size() - 1);
        }
    }

    private boolean isPartition(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;
    }

}

8. 93. 复原 IP 地址 for循环和判断剪枝

问题

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

代码

class Solution {
    public List<String> restoreIpAddresses(String s) {
        List<String> res = new ArrayList<>();
        backtracking(res, new StringBuilder(), s, 0, 0);
        return res;
    }

    private void backtracking(List<String> res, StringBuilder substring, String s, int startIndex, int pointCount) {
        if(startIndex == s.length() && pointCount == 4) {
            String withPointString = substring.toString();
            res.add(withPointString.substring(0, withPointString.length() - 1));
            return;
        }
        // 直接 在 for 循环  剪枝 长度 大于 3 或者 点数 大于等于 4 位的（等于4 位 已经在 前面 判断了）
        for(int i = startIndex; i < s.length() && pointCount < 4 && i - startIndex < 3; i++) {
            if((i > startIndex && s.charAt(startIndex) == '0')) {
                continue;
            }

            String str = s.substring(startIndex, i + 1);
            if(Integer.parseInt(str) >= 0 && Integer.parseInt(str) <= 255) {
                substring.append(str).append(".");
            } else {
                continue;
            }
            backtracking(res, substring, s, i + 1, pointCount + 1);
            substring.deleteCharAt(substring.lastIndexOf("."));
            substring.delete(substring.lastIndexOf(".") + 1, substring.length());
        }
    }

}

9. 78. 子集不剪枝

问题

给你一个整数数组 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 中的所有元素 互不相同

代码

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

    private void backtracking(List<List<Integer>> res, List<Integer> path ,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(res, path, nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

模板

result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
if (startIndex >= nums.size()) { // 终止条件可以不加
    return;
}

10. 90. 子集 II 排序树层去重

问题

给你一个整数数组 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

代码

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        backtracking(res, new ArrayList<Integer>(), nums, 0);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] nums, int startIndex) {
        res.add(new ArrayList<>(path));
        if(startIndex == nums.length) {
            return;
        }
        for(int i = startIndex; i < nums.length; i++) {
            // 去重 条件 只对 广度 有效，也就是 对不同 子集去重
            if(i > startIndex && nums[i] == nums[i - 1]) {
                continue;   
            }
            path.add(nums[i]);
            backtracking(res, path, nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

11. 491. 递增子序列非排序树层去重

问题

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

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

示例1：

输入：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]]

示例2：

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

提示

1 <= nums.length <= 15
-100 <= nums[i] <= 100

代码

class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtracking(res, new ArrayList<Integer>(), nums, 0);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] nums, int startIndex) {
         if (path.size() > 1) {
            res.add(new ArrayList<>(path));
            // 注意这里不要加return，要取树上所有的节点
        }
        // 生命周期 存活在 递归函数中，所以对 同一层有效
        Set<Integer> uset = new HashSet<>();
        for(int i = startIndex; i < nums.length; i++) {
            // 当 path 有值 时，判断 当前 i 所在下标的 值 是否 小于 path 有序列表最后 一个元素 或者 同一层出现 重复元素
            if(path.size() > 0 && nums[i] < path.get(path.size() - 1) || !uset.add(nums[i])) {
                continue;
            }
            //uset.add(nums[i]);
            path.add(nums[i]);
            backtracking(res, path, nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

12. 46. 全排列树枝去重

问题

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例1：

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

示例2：

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

示例3：

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

提示：

1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数 互不相同

代码

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtracking(res, new ArrayList<Integer>(), nums, new boolean[nums.length]);
        return res;
    }
    
    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used) {
        // 全排列，每个元素只能用一次并且全部要用到
        if(path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            // 递归（纵向遍历）不能出现重复，一个元素只能用一次
            if(used[i]) continue;
            path.add(nums[i]);
            used[i] = true;
            backtracking(res, path, nums, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

13. 47. 全排列 II 树枝和树层去重

问题

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例1：

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

示例2：

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

提示：

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

代码

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtracking(res, new ArrayList<Integer>(), nums, new boolean[nums.length]);
        return res;
    }

    private void backtracking(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used) {
        if(path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        Set<Integer> uset = new HashSet<>();
        for(int i = 0; i < nums.length; i++) {
            // 纵向 遍历 同一个下标元素 重复，跳过
            // 否则 横向 遍历 到 重复元素(不同下标)，跳过
            if(used[i] || !uset.add(nums[i])) 
                continue;
            path.add(nums[i]);
            used[i] = true;
            backtracking(res, path, nums, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

二、结束语

评论区可留言，可私信，可互相交流学习，共同进步，欢迎各位给出意见或评价，本人致力于做到优质文章，希望能有幸拜读各位的建议！
—— 与 51cto 同步：https://blog.51cto.com/fyphome
—— 与 csdn 同步：https://blog.csdn.net/F15217283411
—— 转发于个人博客对应回溯题型
—— GitHub 专栏：Fyupeng

专注品质，热爱生活。
交流技术，寻求同志。
—— 延年有余 QQ：1160886967

posted @ 2022-06-16 20:09 延年有余阅读(103) 评论(0) 编辑收藏举报

刷新页面返回顶部

延年有余

回溯——算法

一、算法

1. 22. 括号生成

问题

代码

2. 77. 组合

问题

代码

剪枝优化

3. 216. 组合总和 III

问题

代码

剪枝优化：

4. 17. 电话号码的字母组合

问题

代码

5. 39. 组合总和 树枝剪枝或for循环剪枝

问题

代码

剪枝优化

6. 40. 组合总和 II 排序树层去重

问题

代码

剪枝优化

另一种代码

7. 131. 分割回文串 判断剪枝

问题

代码

8. 93. 复原 IP 地址 for循环和判断剪枝

问题

代码

9. 78. 子集 不剪枝

问题

代码

模板

10. 90. 子集 II 排序树层去重

问题

代码

11. 491. 递增子序列 非排序树层去重

问题

代码

12. 46. 全排列 树枝去重

问题

代码

13. 47. 全排列 II 树枝和树层去重

问题

代码

二、结束语

公告

5. 39. 组合总和树枝剪枝或for循环剪枝

7. 131. 分割回文串判断剪枝

9. 78. 子集不剪枝

11. 491. 递增子序列非排序树层去重

12. 46. 全排列树枝去重