回溯算法基础

最新推荐文章于 2024-08-10 11:53:20 发布
最新推荐文章于 2024-08-10 11:53:20 发布
阅读量98 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qa18252714222/article/details/133282531
版权

回溯算法理论基础

1、什么是回溯法

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。

回溯是递归的副产品，只要有递归就会有回溯。

回溯函数也就是递归函数，指的都是一个函数。

2、回溯法的效率

回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

3、回溯法解决的问题

回溯法，一般可以解决如下几种问题：

  • 组合问题：N个数里面按一定规则找出k个数的集合
  • 切割问题：一个字符串按一定规则有几种切割方式
  • 子集问题：一个N个数的集合里有多少符合条件的子集
  • 排列问题：N个数按一定规则全排列，有几种排列方式
  • 棋盘问题：N皇后，解数独等等

4、回溯的模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

组合问题

1、77. 组合

题意：给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

思路：回溯法

  • 递归函数返回值和参数,返回值为空，参数传入n和k，以及每次递归开始位置startIndex，存储过程的集合path、存储结果的集合result
void combine(int n, int k, int startIndex, List<Integer> path, List<List<Integer>> result)
  • 确定终止条件，当过程集合path的大小等于k时，就可以终止，并将过程集合存储到结果集合中
if (path.size() == k) {
    result.add(new ArrayList<>(path));
    return;
}
  • 确定单次递归的条件
    • for循环条件，i从startIndex开始，当i小于等于n时停止
    • 循环体中，首先将当前i存储到过程集合中，然后递归下一行，递归结束后移除过程集合中的值
  • 剪枝优化：
    • 剪枝优化主要在for循环的终止条件上，比如说4，4，第一层只能等于1，再往后遍历没有意义。
    • 因此可以将for循环的终止条件修改为i <= n - (k - path.size()) + 1
    • image-20220609085756954
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
    path.add(i);
    combine(n, k, startIndex + 1, path, result);
    path.remove(path.size() - 1);
}

整体代码如下：

package com.yzu.lee.recall;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Combine
 * @Description:给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
 * @author: Leekuangyew
 * @date: 2022/6/2 20:13
 */
public class Combine {

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

    private void combine(int n, int k, int startIndex, List<Integer> path, List<List<Integer>> result) {
        if (path.size() == k) {
            result.add(new ArrayList<>(path));
            return;
        }

        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            path.add(i);
            combine(n, k, startIndex + 1, path, result);
            path.remove(path.size() - 1);
        }
    }
}

2、216.组合总和III

题意：找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]

示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

思路：回溯法

  • 确定递归函数返回值和参数，参数传入k和n，传入count用来记录当前值是否已经满足和为n的要求，startIndex为每次递归开始的条件，路径集合path和结果集合result
void combinationSum3(int k, int n, int count, int startIndex, List<Integer> path, List<List<Integer>> result)
  • 确定递归结束的条件，如果当前路径集合的大小等于k，则执行判断count是否等于0，如果等于0，则将路径集合传入到结果集合中，最终返回
if (path.size() == k) {
    if (count == 0) {
        result.add(new ArrayList<>(path));
    }
    return;
}
  • 确定单次递归逻辑，当i小于等于9时，一直循环遍历递归
for (int i = startIndex; i <= 9; i++) {
    path.add(i);
    count -= i;
    combinationSum3(k, n, count, i + 1, path, result);
    path.remove(path.size() - 1);
    count += i;
}
  • 剪枝优化，主要有两处，一处为循环结束条件，当i <= 9 - (k - path.size()) + 1时就结束循环，第二处在循环体中判断count-i如果小于0，则该数层不再继续往后遍历，也不再加树枝
for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
    if(count - i < 0) break;
    path.add(i);
    count -= i;
    System.out.println(count);
    combinationSum3(k, n, count, i + 1, path, result);
    path.remove(path.size() - 1);
    count += i;
}

17.电话号码的字母组合

题意：给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

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

image-20220609093505778

示例: 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].

说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

思路：回溯法

  • 数字与字母的映射关系
String[] strings = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
  • 确定递归函数的返回值和参数，参数传过来按键数字字符串，按键数字与字符串的映射关系数组，以及num用于记录已经统计了几个路径
void letterCombinations(String digits, String[] strings, int num)
  • 确定终止条件，如果按键数字字符串的长度与num相等时，将字符串存入结果集合中
if (digits.length() == num) {
    result.add(sb.toString());
    return;
}
  • 确定单次递归的逻辑，首先根据题目的按键字符串在num位置的字符-’0‘，根据这个值作为索引，去找到映射数组中对应的字符串，然后遍历字符串，递归时需要将num+1；
String string = strings[digits.charAt(num) - '0'];
for (int i = 0; i < string.length(); i++) {
    sb.append(string.charAt(i));
    letterCombinations(digits, strings, num + 1);
    sb.deleteCharAt(sb.length() - 1);
}

整体代码如下：

package com.yzu.lee.recall;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: LetterCombinations
 * @Description:给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
 * 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
 * @author: Leekuangyew
 * @date: 2022/6/5 15:05
 */
public class LetterCombinations {
    List<String> result = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    public List<String> letterCombinations(String digits) {
        if (digits.length() == 0) return result;

        String[] strings = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        letterCombinations(digits, strings, 0);
        return result;
    }

    private void letterCombinations(String digits, String[] strings, int num) {
        if (digits.length() == num) {
            result.add(sb.toString());
            return;
        }

        String string = strings[digits.charAt(num) - '0'];
        for (int i = 0; i < string.length(); i++) {
            sb.append(string.charAt(i));
            letterCombinations(digits, strings, num + 1);
            sb.deleteCharAt(sb.length() - 1);
        }
    }
}

39. 组合总和

题意:给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

  • 所有数字（包括 target）都是正整数。
  • 解集不能包含重复的组合。

示例 1： 输入：candidates = [2,3,6,7], target = 7, 所求解集为： [ [7], [2,2,3] ]

示例 2： 输入：candidates = [2,3,5], target = 8, 所求解集为： [ [2,2,2,2], [2,3,3], [3,5] ]

思路：回溯法

  • 确定递归函数返回值和参数，参数传入candidates和target，传入中间集合list和结果集合result，起始位置startIndex
void combinationSum(int[] candidates, int target, List<Integer> list, List<List<Integer>> result, int startIndex)
  • 确定终止条件，当target等于0时，将中间集合存入到结果集合中，并直接返回
if (target == 0) {
    result.add(new ArrayList<>(list));
    return;
}
  • 确定单次递归的逻辑,由于同一个元素可以重复使用，所以递归时还是传入i，剪枝优化首先对数组进行排序，然后当taeget - candidates[i] < 0时，直接break，即该树层不再继续往后遍历，也不再往下遍历
for (int i = startIndex; i < candidates.length ; i++) {
    if(taeget - candidates[i] < 0) break;
    target -= candidates[i];//剪枝优化
    list.add(candidates[i]);
    combinationSum(candidates, target, list, result, i);
    list.remove(list.size() - 1);
    target += candidates[i];
}

整体代码如下：

package com.yzu.lee.recall;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName: CombinationSum
 * @Description:给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 * candidates 中的数字可以无限制重复被选取。
 * @author: Leekuangyew
 * @date: 2022/6/6  15:55
 */
public class CombinationSum {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        Arrays.sort(candidates);//剪枝优化
        combinationSum(candidates, target, list, result, 0);
        return result;
    }

    private void combinationSum(int[] candidates, int target, List<Integer> list, List<List<Integer>> result, int startIndex) {
        if (target < 0) return;

        if (target == 0) {
            result.add(new ArrayList<>(list));
            return;
        }

        for (int i = startIndex; i < candidates.length ; i++) {
            target -= candidates[i];//剪枝优化
            list.add(candidates[i]);
            combinationSum(candidates, target, list, result, i);
            list.remove(list.size() - 1);
            target += candidates[i];
        }
    }
}

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和target，每次递归开始位置startIndex，中间集合list和结果集合result
void combinationSum2(int[] candidates, int target, int startIndex, List<Integer> list, List<List<Integer>> result)
  • 确定终止条件，如果target等于0，将中间集合添加到结果集合中
if (target == 0) {
    result.add(new ArrayList<>(list));
    return;
}
  • 确定单次递归的逻辑
    • 正常for循环，终止条件为i < candidates.length，i从startIndex开始
    • 剪枝优化，如果target - candidates[i] < 0，直接break
    • 剪枝优化，如果i > startIndex && candidates[i] == candidates[i - 1],直接continue
    • 接下来就是正常的递归回溯
for (int i = startIndex; i < candidates.length; i++) {
    if (target - candidates[i] < 0) break;
    if (i > startIndex && candidates[i] == candidates[i - 1]) continue;
    target -= candidates[i];
    list.add(candidates[i]);
    combinationSum2(candidates, target, i + 1, list, result);
    target += candidates[i];
    list.remove(list.size() - 1);
}

整体代码如下：

package com.yzu.lee.recall;

import com.sun.crypto.provider.PBEWithMD5AndDESCipher;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName: CombinationSum2
 * @Description:给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 * candidates 中的每个数字在每个组合中只能使用一次。
 * @author: Leekuangyew
 * @date: 2022/6/6  17:49
 */
public class CombinationSum2 {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        Arrays.sort(candidates);
        combinationSum2(candidates, target, 0, list, result);
        return result;
    }

    private void combinationSum2(int[] candidates, int target, int startIndex, List<Integer> list, List<List<Integer>> result) {
        if (target < 0) return;
        if (target == 0) {
            result.add(new ArrayList<>(list));
            return;
        }

        for (int i = startIndex; i < candidates.length; i++) {
            if (target - candidates[i] < 0) break;
            if (i > startIndex && candidates[i] == candidates[i - 1]) continue;
            target -= candidates[i];
            list.add(candidates[i]);
            combinationSum2(candidates, target, i + 1, list, result);
            target += candidates[i];
            list.remove(list.size() - 1);
        }
    }
}

重点::使用used数组进行剪枝操作

image-20220609144516067

分割问题

131.分割回文串

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

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

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

思路：回溯法

  • 确定递归函数返回值和参数，参数传入s，递归起始位置startIndex，中间集合list和结果集合result
void partition(String s, int startIndex, List<String> list, List<List<String>> result)
  • 确定终止条件，如果起始位置大于等于字符串s的长度，就直接将中间集合添加到结果中
if (startIndex >= s.length()) {
    result.add(new ArrayList<>(list));
    return;
}
  • 确定单次递归的逻辑
    • 正常for循环，开始i = startIndex，循环结束条件 i < s.length()
    • 判断s的startIndex到i之间是否为回文字串，如果是，则将字符串截断存放到中间集合中，否则直接continue
    • 接下来就是正常的递归
for (int i = startIndex; i < s.length(); i++) {
    if (isPalindrome(s, startIndex, i)) {
        String substring = s.substring(startIndex, i + 1);
        list.add(new String(substring));
    } else continue;
    System.out.println(list);
    partition(s, i + 1, list, result);
    list.remove(list.size() - 1);
}
  • 判断是否为回文子串，利用双指针法进行判断
private boolean isPalindrome(String s, int startIndex, int endIndex) {
    for (int i = startIndex, j = endIndex; i < j; i++, j--) {
        if (s.charAt(i) != s.charAt(j)) return false;
    }
    return true;
}

整体代码如下：

package com.yzu.lee.recall;

import org.hamcrest.core.Is;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Partition
 * @Description:给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
 * 返回 s 所有可能的分割方案。
 * @author: Leekuangyew
 * @date: 2022/6/6  18:16
 */
public class Partition {
    public List<List<String>> partition(String s) {
        List<List<String>> result = new ArrayList<>();
        List<String> list = new ArrayList<>();
        partition(s, 0, list, result);
        return result;
    }

    private void partition(String s, int startIndex, List<String> list, List<List<String>> result) {
        if (startIndex >= s.length()) {
            result.add(new ArrayList<>(list));
            return;
        }

        for (int i = startIndex; i < s.length(); i++) {
            if (isPalindrome(s, startIndex, i)) {
                String substring = s.substring(startIndex, i + 1);
                list.add(new String(substring));
            } else continue;
            System.out.println(list);
            partition(s, i + 1, list, result);
            list.remove(list.size() - 1);
        }

    }

    private boolean isPalindrome(String s, int startIndex, int endIndex) {
        for (int i = startIndex, j = endIndex; i < j; i++, j--) {
            System.out.println(j);
            if (s.charAt(i) != s.charAt(j)) return false;
        }
        return true;
    }
}

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

思路：回溯法

  • 确定递归参数的返回值和参数，参数传入s，以及递归起始位置startIndex，中间集合result和小数点数量pointNum
void backtracking(String s, int startIndex, List<String> result, int pointNum)
  • 确定终止条件，当小数点数量等于3时，判断字符串s的startIndex到s.length() - 1之间是否合法，合法的话就添加到中间节点，并直接返回
if (pointNum == 3) {
    if (isValid(s, startIndex, s.length() - 1)) {
        result.add(s);
    }
    return;
}
  • 确定单次递归的逻辑
    • 正常循环递归
    • 如果当前截取的一部分合法，就直接对s进行处理，截取0到i+1的部分并拼接小数点，和s剩下来的部分
    • 递归时需要将i+2
    • 回溯时记得删除小数点
    • 如果不合法，就直接break
for (int i = startIndex; i < s.length(); i++) {
    if (isValid(s, startIndex, i)) {
        s = s.substring(0, i + 1) + "." + s.substring(i + 1);
        System.out.println(s);
        pointNum++;
        backtracking(s, i + 2, result, pointNum);
        pointNum--;
        s = s.substring(0, i + 1) + s.substring(i + 2);// 回溯删掉逗点
    } else break;
}
  • 判断当前截取的字符串是否满足条件
    • 如果startIndex大于endIndex，直接返回false
    • 如果startIndex不等于endIndex并且startIndex位置的字符串等于0，直接返回false
    • startIndex, endIndex + 1截取字符串
    • 如果这个ip范围在合法范围就直接返回true
private boolean isValid(String s, int startIndex, int endIndex) {
        if (startIndex > endIndex) return false;
        if (startIndex != endIndex && s.charAt(startIndex) == '0') return false;

        String substring = s.substring(startIndex, endIndex + 1);
//      int ip = Integer.parseInt(substring);
        long ip = Long.parseLong(substring);
        if (ip >= 0 && ip <= 255) return true;
        else return false;
    }

子集问题

78.子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

思路：回溯法

  • 确定递归函数的返回值和参数，参数传入nums，递归起始位置startIndex，中间集合path和结果结合result
void backtracking(int[] nums, int startIndex, List<Integer> path, List<List<Integer>> result)
  • 确定终止条件，不需要终止条件，循环结束就可以
  • 确定单次递归的逻辑
    • 每次递归开始，首先将中间集合添加到结果集合中
    • for循环中，正常递归回溯
result.add(new ArrayList<>(path));


for (int i = startIndex; i < nums.length; i++) {
    path.add(nums[i]);
    backtracking(nums, i + 1, path, result);
    path.remove(path.size() - 1);
}

整体代码如下：

package com.yzu.lee.recall;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Subsets
 * @Description:给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 * 说明：解集不能包含重复的子集。
 * @author: Leekuangyew
 * @date: 2022/6/6  21:39
 */
public class Subsets {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums.length == 0) return result;
        List<Integer> path = new ArrayList<>();
        backtracking(nums, 0, path, result);
        return result;
    }

    private void backtracking(int[] nums, int startIndex, List<Integer> path, List<List<Integer>> result) {

        result.add(new ArrayList<>(path));


        for (int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);
            backtracking(nums, i + 1, path, result);
            path.remove(path.size() - 1);
        }
    }
}

90.子集II

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

说明：解集不能包含重复的子集。

示例:

  • 输入: [1,2,2]
  • 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

思路：回溯法

  • 确定递归函数的返回值和参数
void backtracking(int[] nums, int startIndex, List<Integer> path, List<List<Integer>> result, boolean[] used)
  • 确定终止条件，其实不需要
if (startIndex >= nums.length) return;
  • 确定单次递归的逻辑
    • 与上一题类似
    • 增加了去重的过程
      • 当i > 0 && nums[i] == nums[i - 1] && !used[i - 1]时，直接continue
result.add(new ArrayList<>(path));

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

排列问题

46.全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

  • 输入: [1,2,3]
  • 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

思路：回溯法

  • 确定递归函数的返回值和参数
void backtracking(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> result)
  • 确定终止条件，中间集合的大小等于数组的大小，就将中间集合添加到结果集合中，并直接返回
if (path.size() == nums.length) {
    result.add(new ArrayList<>(path));
    return;
}
  • 确定单次递归的逻辑
    • for循环开始，起始位置都是0，终止条件都是i < nums.length
    • 如果used[i]为真，则直接continue，为了给同一个树枝进行去重
    • 其余zjhe
for (int i = 0; i < nums.length; i++) {
    if (used[i]) continue;
    used[i] = true;
    path.add(nums[i]);
    backtracking(nums, used, path, result);
    path.remove(path.size() - 1);
    used[i] = false;
}

整体代码如下：

package com.yzu.lee.recall;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Permute
 * @Description:给定一个 没有重复 数字的序列，返回其所有可能的全排列。
 * 示例:
 * 输入: [1,2,3]
 * 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]
 * @author: Leekuangyew
 * @date: 2022/6/8 9:43
 */
public class Permute {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums.length == 0) return result;
        List<Integer> path = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        backtracking(nums, used, path, result);
        return result;
    }

    private void backtracking(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> result) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums, used, path, result);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

47.全排列 II

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

示例 1：

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

思路：回溯法

  • 确定递归函数的返回值和参数
void backtracking(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> result)
  • 确定终止条件
if (path.size() == nums.length) {
    result.add(new ArrayList<>(path));
}
  • 确定单次递归的逻辑
    • 同一树层去重，if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
    • 同一树枝去重，if (used[i]) continue;
for (int i = 0; i < nums.length; i++) {
    if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
    if (used[i]) continue;
    path.add(nums[i]);
    used[i] = true;
    backtracking(nums, used, path, result);
    path.remove(path.size() - 1);
    used[i] = false;
}

整体代码如下：

package com.yzu.lee.recall;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName: PermuteUnique
 * @Description:给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
 * @author: Leekuangyew
 * @date: 2022/6/8  11:49
 */
public class PermuteUnique {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums.length == 0) return result;
        List<Integer> path = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(nums, used, path, result);
        return result;

    }

    private void backtracking(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> result) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
        }

        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
            if (used[i]) continue;
            path.add(nums[i]);
            used[i] = true;
            backtracking(nums, used, path, result);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

其他问题

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

  • 输入: [4, 6, 7, 7]
  • 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

  • 给定数组的长度不会超过15。
  • 数组中的整数范围是 [-100,100]。
  • 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

思路：回溯法

  • 确定递归函数的返回值和参数
void backtracking(int[] nums, int startIndex, List<Integer> path, List<List<Integer>> result)
  • 确定终止条件，当中间集合的大小大于等于2时，将中间集合添加到结果集合中
if (path.size() >= 2) {
    result.add(new ArrayList<>(path));
}
  • 确定单次递归的逻辑
    • 每层新建一个map
    • 如果!path.isEmpty() && path.get(path.size() - 1) > nums[i],直接continue
    • 如果map.get(nums[i]) != null && map.get(nums[i]) >= 1,说明同一树层已经有了，直接continue
Map<Integer, Integer> map = new HashMap<>();
for (int i = startIndex; i < nums.length; i++) {
    if (!path.isEmpty() && path.get(path.size() - 1) > nums[i]) continue;
    //因为数组不是递增的，所以不能使用这种方式直接判断
    //if (i>startIndex && nums[i] == nums[i-1]) continue;
    if (map.get(nums[i]) != null && map.get(nums[i]) >= 1) continue;
    map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
    path.add(nums[i]);
    backtracking(nums, i + 1, path, result);
    path.remove(path.size() - 1);
}
Leekuangyee
关注
回溯算法——五大常用算法之一
likunkun__的博客
05-20 3791
1.概念    回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回到上一步还能执行的状态，尝试别的路径。    类似于走迷宫一样，假设我们到了每一个岔路口都规定，除了走过的地方，按照先往上走到底，如果不能走，在退回到上一个岔路口，走左边，如果不行再走右边，如果不行再走下面。每次退回就是每次的回溯，所以回溯法要保存每一次的状态。  ...
算法基础——回溯法
haoTaoshu的博客
07-31 573
目录 一、算法思想 二、算法要素 三、回溯法求解0-1背包问题代码 一、算法思想 回溯法是一种选优搜索法，按照选优条件深度优先搜索，以达到目标。当搜索到某一步，发现原先选择并不是最优或达不到目标，就退回一步重新选择。其核心思想为“能进则进，进不了则换，换不了则退”。 二、算法要素 1.解空间 确定问题的解的形式，以及对解的分量的显约束。解空间就是所有可能解组成的空间。 2.解空...
回溯算法理论基础
qq_45799360的博客
04-21 207
回溯算法理论基础 一 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数。 二 回溯法的效率 回溯法的性能如何呢，这里要和大家说清楚了，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 因为回溯的本质是穷举，穷举所有可能，然后选...
回溯函数(算法)杂谈 -----可主动控制撤回逻辑处理的递归函数
最新发布
weixin_56228133的博客
08-10 902
回溯，对接触了算法的人而言，并不陌生，其实严谨地说回溯函数就是递归函数，只不过在使用上，人们将它的一些细节抽离出来，进而演化出了所谓的回溯，在算法导论中，与其相关的被称为“回溯搜索算法”。回溯本质是递归的副产物，只要有递归调用就会有回溯。回溯法也经常和二叉树或N叉树遍历，深度优先搜索混在一起，因为这两种方式的简单实现都是用了递归(当然可以使用数据结构的栈模拟递归，来设计搜索遍历算法)。
回溯算法理论及应用
qq_41721746的博客
03-19 1967
一. 回溯算法基础理论 二. 子集树 1. 输出所有的子集 2. 整数选择问题求解 3. 2N整数选择问题 4. 挑数字问题 (1) 使用子集树解决 (2) 使用枚举法解决 三. 排列数 1. 0-1背包问题 2. 排列树理论及代码实现 3. 八皇后问题求解 4. 基于穷举法的全排列实现
回溯
weixin_33971130的博客
01-08 70
1、NFA引擎最重要的性质是：遇到两个匹配成功的情况，选择其中的一个，同时记住另一个，作为备选状态。 2、需要做出选择的情况有：量词和多选结构。量词是匹配优先的，而多选结构往往是按顺序选择的。 3、选择一条支路，全局匹配成功，匹配结束。如果失败，后退一步，选择另一条支路，后退只是后退一步，符合后进先出。如果全局匹配成功，return 成功。如果尝试了所有的路径，还不成功，return 匹配失败...
回溯算法
Marmara
12-05 1671
一、基本介绍 （一）概念        回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。        回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。...
算法基础（Java）--回溯算法
m0_73757009的博客
03-15 982
s的每一个元素s【i】(i >= 0&&i < n),都为数组a中的任意元素a【j】(j >= 0&&j < n)，不过要保证任意的s【i】不相等。乘以2，格子上填的就是左括号或者右括号，这里的剪枝条件是，当前右括号数量超过了左括号，或左括号数量超过了一半。上面的i代表解空间的第i个位置，往往从0开始，而n则代表解空间的大小。因此我们看到，回溯本身是很简单的，单纯的模板套用，难的在于需要根据回溯条件来定义各种别的变量，以及最后结果的记录。这个向量的每个元素都是问题的部分解，只有当这个数组的每一个元素都。
回溯算法全代码
03-15
一、回溯算法基础 1. **基本思想**：回溯算法通过深度优先搜索（DFS）策略来遍历问题的所有可能解。在搜索过程中，每当遇到一个不满足条件的解时，就撤销最近的决策并尝试其他可能的选择，这个过程称为回溯。 2. *...
「代码随想录」回溯算法精讲（v1.1）.pdf
08-11
由于提供的文件内容主要是对「代码...不过，根据以上总结的知识点，我们可以大致理解回溯算法的理论基础和实现逻辑。如果读者需要更深入的学习，可以通过访问提供的Github链接（***）获取更丰富的学习资源和实际案例。
基于python实现根据最短路径回溯算法提取血管的中心线+源码（期末大作业）
06-05
基于python实现根据最短路径回溯算法提取血管的中心线+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于python实现根据最短路径回溯算法提取血管的中心线...
Java实现回溯算法入门（排列+组合+子集）
小朱小朱绝不认输的博客
10-27 8142
回溯是递归的副产品，只要有递归就会有回溯，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 回
【模板】回溯法 （八皇后、素数环题解）
coderwait
04-29 938
回溯法 在问题的解空间树中，按深度优先策略从根结点出发搜索解空间树。算法搜索到解空间树任一结点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯。否则，进入该子树继续按照深度优先策略搜索。 两种剪枝策略 1. 用约束函数在扩展结点处减去不满足约束的子树。 2. 用限界函数剪去得不到最优解的子树。 伪代码模板 void dfs(int...
linux查看函数的回溯函数
野生猿-群号1025127672
05-28 761
所谓回溯，就是查看谁在调用某个函数。最直接的方法就是用sourceInsight，右击某个函数-&gt;选择jump to caller，这种方法有时候会产生很多调用者，看不出到底是谁在调用。另一种方法就是运行时打印，linux提供了回溯的功能，在想要回溯的函数中，加入代码：dump_stack();运行时在控制台就会看到打印，依次打印出了谁在调用它，一直回溯到最上层的应用层函数...
python实现回溯算法
liulanba的博客
03-10 2036
回溯算法是一种经典的解决组合优化问题、搜索问题以及求解决策问题的算法。它通过不断地尝试各种可能的候选解，并在尝试过程中搜索问题的解空间，直到找到问题的解或者确定问题无解为止。回溯算法常用于解决诸如排列、组合、子集、棋盘类等问题。if 满足结束条件: # 如果已经满足结束条件result.append(path[:]) # 将当前路径添加到结果中returnfor 选择 in 候选集: # 遍历所有候选选择if 当前选择合法: # 如果当前选择是合法的做出选择 # 将当前选择添加到路径中。
回溯算法及其应用
m0_72379992的博客
10-15 1249
回溯算法是一种常用于解决组合优化问题、搜索问题和决策问题的算法。事实上，回溯正是的副产物，回溯算法就是通过递归实现的算法。他通过遍历所有情况来找到问题的解，若当前方案不可行，就会回溯（回退）并尝试其他可能的路径。和多层嵌套for循环相比，这种递归试错的方法不必设计的for循环，有效减轻了代码的复杂度，有利于算法在大规模的搜索空间中寻找最佳解决方案。回溯算法的本质是所有可能情况，虽然它的时间复杂度可能很高，但在许多复杂情况下，它仍然是一个可行的解决方案。
【回溯专题】—— 回溯算法入门篇
欢迎来到我的世界
05-21 3642
当前包含全排列、N皇后、组合、电话号码的字符组合
回溯算法详解与实战
“回溯算法讲解与实现，包括算法思想、解空间定义以及实例分析。” 回溯算法是一种在解决问题时，通过尝试所有可能的解决方案并逐步构造答案来找到有效解的方法。它主要用于处理那些解空间巨大，但存在约束条件的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Leekuangyee

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值