1.回溯算法介绍

1.来源

回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。

用回溯算法解决问题的一般步骤：

1、 针对所给问题，定义问题的解空间，它至少包含问题的一个（最优）解。

2 、确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间 。

3 、以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

确定了解空间的组织结构后，回溯法就从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。这个开始结点就成为一个活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点。这个新结点就成为一个新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。 [2]

2.基本思想

回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。八皇后问题就是回溯算法的典型，第一步按照顺序放一个皇后，然后第二步符合要求放第2个皇后，如果没有位置符合要求，那么就要改变第一个皇后的位置，重新放第2个皇后的位置，直到找到符合条件的位置就可以了。回溯在迷宫搜索中使用很常见，就是这条路走不通，然后返回前一个路口，继续下一条路。回溯算法说白了就是穷举法。不过回溯算法使用剪枝函数，剪去一些不可能到达 最终状态（即答案状态）的节点，从而减少状态空间树节点的生成。回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题。

2.代码介绍

private static void generateMedicationCombinations() {
        // 存储所有药品的列表
        List<Medication> medications = new ArrayList<>();

        // 从用户那里获取药品的数量
        System.out.println("请输入药品数量：");
        int medicationCount = scanner.nextInt();
        scanner.nextLine(); // 读取并忽略换行符

        // 循环获取每种药品的详细信息
        for (int i = 0; i < medicationCount; i++) {
            System.out.println("请输入第 " + (i + 1) + " 个药品的名称：");
            String name = scanner.nextLine();
            System.out.println("请输入第 " + (i + 1) + " 个药品的剂量：");
            int dose = scanner.nextInt();
            System.out.println("请输入第 " + (i + 1) + " 个药品的价格：");
            int cost = scanner.nextInt();
            scanner.nextLine(); // 读取并忽略换行符
            // 将药品对象添加到列表中
            medications.add(new Medication(name, dose, cost));
        }

        // 从用户那里获取目标总剂量和目标总价格
        System.out.println("请输入目标总剂量：");
        int targetDose = scanner.nextInt();
        System.out.println("请输入目标总价格：");
        int targetCost = scanner.nextInt();
        scanner.nextLine(); // 读取并忽略换行符

        // 存储所有可能的药品组合的列表
        List<List<Medication>> combinations = new ArrayList<>();
        // 调用递归函数来找出所有可能的组合
        findCombinations(medications, new ArrayList<>(), combinations, targetDose, targetCost, 0);

        // 打印所有可能的药品组合
        System.out.println("所有可能的药品组合：");
        int combinationNumber = 1;
        for (List<Medication> combination : combinations) {
            int totalDose = combination.stream().mapToInt(Medication::getDose).sum();
            int totalCost = combination.stream().mapToInt(Medication::getCost).sum();
            System.out.println("第 " + combinationNumber + " 个组合：" + combination + "，总剂量：" + totalDose + "，总价格：" + totalCost);
            combinationNumber++;
        }
    }

    /**
     * 使用回溯算法找出所有可能的药品组合。
     * 函数递归地尝试添加每一种药品到当前组合中，
     * 并在满足条件时记录组合。
     */
    private static void findCombinations(List<Medication> medications, List<Medication> currentCombination, List<List<Medication>> combinations, int targetDose, int targetCost, int start) {
        // 计算当前组合的总剂量和总成本
        int currentDose = currentCombination.stream().mapToInt(Medication::getDose).sum();
        int currentCost = currentCombination.stream().mapToInt(Medication::getCost).sum();

        // 如果当前组合不为空，并且其剂量和成本不超过目标值，则将其添加到组合列表中
        if (currentDose <= targetDose && currentCost <= targetCost && !currentCombination.isEmpty()) {
            combinations.add(new ArrayList<>(currentCombination));
        }

        // 如果当前组合的剂量或成本已经达到或超过目标值，则停止递归
        if (currentDose >= targetDose || currentCost >= targetCost) {
            return;
        }

        // 从start开始，尝试将每种药品添加到当前组合中
        for (int i = start; i < medications.size(); i++) {
            // 添加药品到当前组合
            currentCombination.add(medications.get(i));
            // 递归调用函数，尝试添加更多的药品
            findCombinations(medications, currentCombination, combinations, targetDose, targetCost, i + 1);
            // 回溯：从当前组合中移除最后添加的药品，为下一次迭代做准备
            currentCombination.remove(currentCombination.size() - 1);
        }
    }

3.使用 “回溯算法”来生成所有可能的药品组合。 

实现一个药品组合生成器，其目的是找出所有可能的药品组合，这些组合的总剂量和总价格不超过用户指定的目标剂量和目标价格。使用了回溯算法来解决这个问题。

代码中每个方法的概括：

1. `generateMedicationCombinations()`:
   - 主方法，负责程序的流程控制。
   - 首先，它初始化一个药品列表并提示用户输入药品的数量。
   - 然后，它循环提示用户输入每种药品的名称、剂量和价格，并将这些药品对象添加到列表中。
   - 接下来，它提示用户输入目标总剂量和目标总价格。
   - 调用`findCombinations()`方法来找出所有可能的药品组合，并存储在`combinations`列表中。
   - 最后，它遍历`combinations`列表并打印出每个组合及其总剂量和总价格。

2. `findCombinations(List<Medication> medications, List<Medication> currentCombination, List<List<Medication>> combinations, int targetDose, int targetCost, int start)`:
   - 递归方法，用于实现回溯算法。
   - 它接收当前药品列表、当前组合、所有组合的列表、目标剂量、目标成本以及起始索引作为参数。
   - 该方法首先计算当前组合的总剂量和总成本。
   - 如果当前组合的剂量和成本都不超过目标值，并且组合不为空，则将当前组合添加到所有组合的列表中。
   - 如果当前组合的剂量或成本已经超过目标值，则停止递归。
   - 否则，它将从`start`索引开始，尝试将每种药品添加到当前组合中，并递归调用自身。
   - 在每次递归调用之后，它会从当前组合中移除最后添加的药品，这是回溯算法的关键步骤，允许算法尝试其他可能的组合。

使用了一些关键的Java集合和流操作，例如`ArrayList`用于存储药品和组合，以及`stream().mapToInt()`用于计算总剂量和总成本。