Java 使用递归将偶数整数分离为2,4,6的和

我必须用Java编写一个递归方法，使用递归将偶数整数分解为2,4,6的和，同时一行中不能有2个相同的数字

例如

n=8

返回：

([2,4,2], [2,6], [6,2])

(where [2,2,2,2], [2,2,4], [4,2,2], [4,4] are not allowed as answers)

我正在寻找实现这一点的算法。现在我想我需要给这个方法两个参数，一个是

intn

，另一个是

ArrayList

，以存储找到的分离方法。但我很难想出一个算法来实现这一点

public static ArrayList<Integer> subtractions(int n, ArrayList<Integer> integers){
    int sum = 0;
    for(Integer i:integers){
        sum += i;
    }
    if(n>2 && sum<n) {
        integers.add(n - 2);
        return subtractions(n - 2, integers);
    }
    integers.add(2);
    return integers;
}

公共静态ArrayList减法（int n，ArrayList整数）{
整数和=0；
for（整数i：整数）{
总和+=i；
}
如果（n>2&&sum您缺少一个完整的复杂性级别。您不应该处理整数列表，而应该处理整数列表。这个问题更多地是关于数据结构，而不是关于数学。我的示例解决方案：

public static List<List<Integer>> subtractions_recursive(int target, int exclude) {

    List<List<Integer>> solutions = new ArrayList<>();

    if (target == 0) { // base case for recursion
        List<Integer> empty = new ArrayList<>(); // ()
        solutions.add(empty); // (())
    } else {
        for (int i = 2; i <= 6 && target - i > -1; i += 2) {
            if (i == exclude) {
                continue;
            }

            List<List<Integer>> sub_solutions = subtractions_recursive(target - i, i); // ((4, 2), (6))

            for (List<Integer> sub_solution:sub_solutions) {
                sub_solution.add(0, i); // ((2, 4, 2), (2, 6))
            }

            solutions.addAll(sub_solutions);
        }
    }

    return solutions; // ((2, 4, 2), (2, 6), (6, 2))
}

public static List<List<Integer>> subtractions(int target) {
    return subtractions_recursive(target, 0);
}

公共静态列表减法\u递归（int-target，int-exclude）{
列表解决方案=新的ArrayList（）；
if（target==0）{//递归的基本情况
List empty=new ArrayList（）；/（）
解决方案。添加（空）；/（（））
}否则{
对于（int i=2；i-1；i+=2）{
如果（i==排除）{
继续；
}
列表子解=减法递归（目标-i，i）；/（（4，2），（6））
用于（列出子_解决方案：子_解决方案）{
子解。加上（0，i）；/（（2，4，2），（2，6））
}
解决方案。添加所有（子_解决方案）；
}
}
返回溶液；/（（2,4,2）、（2,6）、（6,2））
}
公共静态列表减法（int目标）{
递归返回减法（目标，0）；
}
您的问题似乎与有关。还有另一篇文章。这两篇文章都很好地理解了您将面临的问题的复杂性，并开发了您的解决方案。您可能需要进行一些调整，删除所有具有相同数字序列的子集。
祝你好运