如何从二维int数组中生成所有可重复元素的不重复组合？

看起来你需要的是生成所有允许元素重复选取的有序组合（也就是元素集合的笛卡尔积），而不是那种从每个子数组各选一个元素的常规组合。之前你尝试的方案无效，大概率是因为那些方案针对的是“从每个子数组选一个且不重复使用子数组”的场景，和你的核心需求不匹配。

核心思路 #

首先把二维数组扁平化，得到所有可选的元素列表；然后生成所有长度为目标值（比如你的示例中是2）的有序组合，每个位置的元素都可以从扁平化后的列表中任意选取（包括重复元素），确保每个唯一的组合只生成一次。

Java 实现代码 #

1. 扁平化二维数组

先把输入的二维数组转换成一维元素列表，方便后续处理：

int[][] values = new int[][] {{1, 2}, {3, 4}};
List<Integer> elements = new ArrayList<>();
for (int[] subArray : values) {
    for (int num : subArray) {
        elements.add(num);
    }
}

2. 迭代法生成组合

这种方法直观易懂，通过迭代逐步构建不同长度的组合：

public static List<List<Integer>> generateCombinations(List<Integer> elements, int targetLength) {
    List<List<Integer>> result = new ArrayList<>();
    // 初始化：先生成所有长度为1的组合
    for (int num : elements) {
        List<Integer> single = new ArrayList<>();
        single.add(num);
        result.add(single);
    }
    // 迭代扩展组合长度，直到达到目标长度
    for (int i = 1; i < targetLength; i++) {
        List<List<Integer>> temp = new ArrayList<>();
        for (List<Integer> existingCombo : result) {
            for (int num : elements) {
                List<Integer> newCombo = new ArrayList<>(existingCombo);
                newCombo.add(num);
                temp.add(newCombo);
            }
        }
        result = temp;
    }
    return result;
}

3. 递归法生成组合

如果更喜欢递归风格，也可以用这种回溯方式实现：

public static void generateCombinationsRecursive(List<Integer> elements, int targetLength, List<Integer> currentCombo, List<List<Integer>> result) {
    // 递归终止条件：当前组合长度达到目标
    if (currentCombo.size() == targetLength) {
        result.add(new ArrayList<>(currentCombo));
        return;
    }
    // 遍历所有元素，添加到当前组合后继续递归
    for (int num : elements) {
        currentCombo.add(num);
        generateCombinationsRecursive(elements, targetLength, currentCombo, result);
        currentCombo.remove(currentCombo.size() - 1); // 回溯，移除当前元素继续尝试其他选项
    }
}

4. 调用并输出结果

以你的示例为例，目标组合长度是2，调用方法并按照你想要的格式输出：

public static void main(String[] args) {
    int[][] values = new int[][] {{1, 2}, {3, 4}};
    List<Integer> elements = new ArrayList<>();
    for (int[] subArray : values) {
        for (int num : subArray) {
            elements.add(num);
        }
    }

    // 用迭代法生成组合
    List<List<Integer>> combinations = generateCombinations(elements, 2);
    // 或者用递归法生成
    // List<List<Integer>> combinations = new ArrayList<>();
    // generateCombinationsRecursive(elements, 2, new ArrayList<>(), combinations);

    // 按照[X-Y]的格式输出结果
    for (List<Integer> combo : combinations) {
        System.out.printf("[%d-%d]%n", combo.get(0), combo.get(1));
    }
}

输出结果 #

运行后会生成所有16个唯一的有序组合，包含你提到的[1-2]、[2-1]、[3-2]、[2-3]、[3-3]、[2-2]、[1-3]、[1-1]，以及其他符合要求的组合，每个组合只出现一次。

为什么之前的方案无效 #

你提到的《All possible combinations of a 2D array》类方案，通常是解决“从每个子数组中选取一个元素，每个子数组只能用一次”的问题，比如对于你的输入会生成[1,3]、[1,4]、[2,3]、[2,4]这4种组合，完全不允许重复选取元素或跨子数组重复选取，和你“允许元素重复、生成所有有序组合”的需求完全不匹配，所以会无效。

内容的提问来源于stack exchange，提问作者MrEAZL