简单例子1

下面是一个 Java 实现的简单回溯例子，通过回溯算法实现从一个给定数组中选出若干个数字，使它们的和等于给定的目标值。

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

public class BacktrackingExample {
    public static void backtrack(int[] nums, int target, List<Integer> path, List<List<Integer>> res) {
        if (target < 0) {
            return;
        } else if (target == 0) {
            res.add(new ArrayList<>(path));  // 将当前解加入到结果集中
            return;
        }`在这里插入代码片`

    for (int i = 0; i < nums.length; i++) {
        // 尝试将当前数加入到当前解中
        path.add(nums[i]);
        // 递归处理剩余的数
        backtrack(nums, target - nums[i], path, res);
        // 回溯，将当前数移除
        path.remove(path.size() - 1);
    }
}

public static void main(String[] args) {
    int[] nums = {2, 3, 6, 7};
    int target = 7;
    List<List<Integer>> res = new ArrayList<>();
    backtrack(nums, target, new ArrayList<>(), res);
    System.out.println(res);
}

}
输出结果为：

[[2, 2, 3], [7]]
这里的解是一个列表，其中每个子列表表示一种可能的选数方案，满足选出的数字之和等于目标值。

在这个例子中，我们首先判断是否达到了目标值，如果达到了则将当前解加入到结果集中。如果目标值还没有达到，则依次考虑每个数在当前位置的选或不选两种情况，对剩余的数进行递归处理，直到选完整个数组，将所有选的数作为一个解。如果当前的数不能选，则回溯，将当前数移除重新考虑其他情况。

2024/4/9 16:12:14

[2, 2, 3] 是个什么

2024/4/9 16:12:15

[2, 2, 3] 是一个包含三个元素的整数数组，它是一个回溯算法的解，表示从给定的数组 [2, 3, 6, 7] 中选出若干个数，使它们的和等于目标值 7 的一种方案。在这个例子中，我们可以选出 2、2 和 3 三个数，它们的和正好等于 7。

2024/4/9 16:12:39

2 不是重复了吗

2024/4/9 16:12:47

是的，你说得对。在这个例子中，[2, 2, 3] 中的 2 出现了两次，这是因为在回溯算法的过程中，我们可以重复选取给定数组中的每个数，因此可能会出现重复的情况。如果要避免重复，我们可以在回溯算法中剪枝，即在递归的过程中去掉不合法的分支，从而减少重复的情况。

下面是一个修改后的 Java 实现的回溯例子，它可以避免重复：

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

public class BacktrackingExample {
public static void backtrack(int[] nums, int target, int start, List path, List<List> res) {
if (target < 0) {
return;
} else if (target == 0) {
res.add(new ArrayList<>(path)); // 将当前解加入到结果集中
return;
}

    for (int i = start; i < nums.length; i++) {
        if (i > start && nums[i] == nums[i - 1]) {
            continue;  // 如果当前的数和前一个数相同，则跳过当前循环
        }
        // 尝试将当前数加入到当前解中
        path.add(nums[i]);
        // 递归处理剩余的数
        backtrack(nums, target - nums[i], i + 1, path, res);
        // 回溯，将当前数移除
        path.remove(path.size() - 1);
    }
}

public static void main(String[] args) {
    int[] nums = {2, 2, 3, 7};
    int target = 7;
    Arrays.sort(nums);  // 需要先将数组排序
    List<List<Integer>> res = new ArrayList<>();
    backtrack(nums, target, 0, new ArrayList<>(), res);
    System.out.println(res);
}

}
输出结果为：

[[2, 2, 3], [7]]
在这个例子中，我们首先将数组排序，然后在递归的过程中添加了一个 start 参数，表示当前可以选取的数的起始下标，从而避免了重复选取。在每次循环中，如果当前的数和前一个数相同，则跳过当前循环，去掉重复的情况。