Question

我正在练习一些编码问题，由于某些原因，我无法为以下问题找到解决方案。如果有人可以帮助我解决算法或代码，我将不胜感激。

给出一个二维数组，例如

 {{1}, {2,3}, {4,5,6}}

我们需要生成所有可能的组合，以便从每个数组中精确选择一个元素。

因此，对于上述输入，结果集应为

{{1,2,4}, {1,2,5}, {1,2,6}, {1,3,4}, {1,3,5}, {1,3,6}}

另一个例子：

Input = {{1,2,3}, {1,2}, {4,5}}
Output = {{1,1,4}, {1,1,5}, {1,2,4}, {1,2,5}, {2,1,4}, {2,1,5}, {2,2,4}, {2,2,5},{3,1,4}, {3,1,5}, {3,2,4}, {3,2,5}}

我尝试实现笛卡尔乘积方法，但是在维护修改后的列表时遇到了问题。该代码不起作用，因为我正在更新结果列表本身，这使我得到的最终结果为[[1,2,3]，[1,2,3]]，但应为[[1,2]，[1 ，3]]

public class CartisianProduct {
public static void main(String[] args) {
    int[][] arr = { { 1 }, { 2, 3 } };
    cartisian(arr);
}

private static void cartisian(int[][] arr) {
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    List<Integer> ll = new ArrayList<Integer>();
    for (int i : arr[0]) {
        ll.add(i);
    }
    result.add(ll);

    for (int i = 1; i < arr.length; i++) {
        result = cartisianHelper(result, arr[i]);
    }
    //System.out.println(result.get(0).toString() + "-" + result.get(1).toString());
}

private static List<List<Integer>> cartisianHelper(List<List<Integer>> result, int[] arr) {

    List<List<Integer>> rs = new ArrayList<List<Integer>>();
    List<List<Integer>> temp = new ArrayList<List<Integer>>();
    temp.addAll(result);
    for (int i = 0; i < result.size(); i++) {

        for (int j = 0; j < arr.length; j++) {
            List<Integer> ll = temp.get(i);
            ll.add(arr[j]);
            rs.add(ll);
        }
    }
    return rs;
}
}

Answer 1

import java.util.ArrayList;
import java.util.List;
class Solution{
    public static void main(String[] args){
        int[][] arr1 = {{1,2,3}, {1,2}, {4,5}};
        System.out.println(cartesianProduct(arr1,0,arr1.length).toString());
        int[][] arr2 = {{1},{2,3},{4,5,6}};
        System.out.println(cartesianProduct(arr2,0,arr2.length).toString());
        int[][] arr3 = {};
        System.out.println(cartesianProduct(arr3,0,arr3.length).toString());
        int[][] arr4 = {{1},{2}};
        System.out.println(cartesianProduct(arr4,0,arr4.length).toString());
        int[][] arr5 = {{99,101},{2000}};
        System.out.println(cartesianProduct(arr5,0,arr5.length).toString());
        int[][] arr6 = {{1},{2},{3},{4},{5},{6}};
        System.out.println(cartesianProduct(arr6,0,arr6.length).toString());
    }

    private static List<List<Integer>> cartesianProduct(int[][] arr,int curr_row,int length){
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(curr_row == length) return res;

        List<List<Integer>> subproblem_result = cartesianProduct(arr,curr_row + 1,length);
        int size = subproblem_result.size();

        for(int i=0;i<arr[curr_row].length;++i){            
            if(size > 0){
                for(int j=0;j<size;++j){
                   List<Integer> current_combs = new ArrayList<>();
                   current_combs.add(arr[curr_row][i]);
                   current_combs.addAll(subproblem_result.get(j));
                   res.add(current_combs);
                }  
            }else{
                List<Integer> current_combs = new ArrayList<>();
                current_combs.add(arr[curr_row][i]);
                res.add(current_combs);
            }              
        }        

        return res;
    }
}

输出：

[[1, 1, 4], [1, 1, 5], [1, 2, 4], [1, 2, 5], [2, 1, 4], [2, 1, 5], [2, 2, 4], [2, 2, 5], [3, 1, 4], [3, 1, 5], [3, 2, 4], [3, 2, 5]]
[[1, 2, 4], [1, 2, 5], [1, 2, 6], [1, 3, 4], [1, 3, 5], [1, 3, 6]]
[]
[[1, 2]]
[[99, 2000], [101, 2000]]
[[1, 2, 3, 4, 5, 6]]

说明：

我们可以采用自上而下的方法（例如您的代码尝试执行的方法）或自下而上的方法，但是让我们采用自下而上的方法，因为您会更好地理解它。
让我们以{{1,2,3}, {1,2}, {4,5}}为例。
我们将cartesianProduct()递归调用到最深的级别，即直到最后一行。如果通话次数超出限制，我们将返回一个空列表。
在最深层，我们将处于代码中的{4,5}位置。通过创建一个新列表，添加元素，最后将此列表添加到列表集合中，我们将每个元素添加到列表中。因此，我们将列表以[[4],[5]]的形式返回到下一行。
下一行是{1,2}。在这里，我们再次对其元素进行迭代，同时，我们将该元素添加到连续行返回的列表集合内的每个列表中。因此，我们将1添加到[4]，将1添加到[5]，将2添加到[4]，并且将2添加到{{1} }。因此，现在我们返回的新集合看起来像[5]。
下一行是[[1,4],[1,5],[2,4],[2,5]]。我们做与上面相同。因此，我们将{1,2,3}添加到1中的每个列表中，[[1,4],[1,5],[2,4],[2,5]]和2也是如此。
因此，我们的最终列表看起来像3。
最后，我们只照常返回列表，并使用toString（）方法将其打印出来。
请注意，如果您使用自上而下的方法，您仍将得出正确的答案，但所获得的组合顺序将与您预期的不同。

Answer 2

在处理PHP项目时，我遇到了同样的问题，发现这个主题为我提供了正确的输入。这是我相当简短的解决方案（在PHP中），不需要任何递归函数：

    $startlist = [ [1] , [2, 3] , [4, 5, 6]];

    $cartesian = [ [] ];    // Start with one empty element in the cartesian product result array
    foreach($startlist as $subarray){       // iterate over the startlist
        $newcartesian = [];                 // temporary helper
        foreach($subarray as $element){     // Iterate over all elements of the subarrays
            foreach($cartesian as $cartesiansubarray){      // iterate over each element in the cartesian product the we already have
                $cartesiansubarray[] = $element;            // add the element to each of these and
                $newcartesian[] = $cartesiansubarray;       // add them to the temporary helper
            }
        }
        $cartesian = $newcartesian;     // replace the cartesian product by the helper
    }

    echo json_encode($cartesian);       // json_encode() is just used to have a shorter printout

输出符合预期：

[[1,2,4]，[7,2,4]，[1,3,4]，[7,3,4]，[1,2,5]，[7,2,5 ]，[1,3,5]，[7,3,5]，[1,2,6]，[7,2,6]，[1,3,6]，[7,3,6]]

数组数组中的所有组合

2 个答案: