Algorithm 有没有一种算法可以在二维列表中不重复地查找排列？

我的输入由一个二维整数值列表组成。 二维列表可以包含如下示例所示的三个列表：

L1   L2    L3
--------------
1    11    111
2    22    222
3    33
4

目标是以正确的顺序将每个元素与其他元素组合起来。 结果也必须是一个二维列表。 二维列表中的每个列表的大小为n，其中n是输入列表的数量。 将产生以下结果：

L1:  1, 11, 111
L2:  1, 11, 222
L3:  1, 22, 111
L4:  1, 22, 222
L5:  1, 33, 111
L6:  1, 33, 222

L7:  2, 11, 111
L8:  2, 11, 222
L9:  2, 22, 111
.
.
.
L24: 4, 33, 222

---

每个问题都必须有正确的顺序，如示例所示。

这个问题可以递归解决。算法非常简单，唯一棘手的部分是当列表中有重复的数字时避免重复排列。这样做的一个好方法是对每个列表进行排序，因此当从每个列表中选取整数时，很容易判断是否选取了特定的数字。下面是以您提供的示例作为测试用例的实现。您可以将列表的值更改为包含重复的数字，并查看输出不包含重复的排列

public class ListPermutation {
    public static List<List<Integer>> generateUniqueListPermutations(List<List<Integer>> lists) {
        List<List<Integer>> permutations = new ArrayList<>();
        if(lists == null || lists.size() == 0) {
            return permutations;
        }
        //sort each input list
        for(List<Integer> list : lists) {
            Collections.sort(list);
        }
        permutationHelper(lists, permutations, new ArrayList<>(), 0);
        return permutations;
    }
    private static void permutationHelper(List<List<Integer>> lists, List<List<Integer>> permutations, List<Integer> list, int idx) {
        if(idx == lists.size()) {
            permutations.add(new ArrayList<>(list));
            return;
        }
        List<Integer> currList = lists.get(idx);
        for(int i = 0; i < currList.size(); i++) {
            if(i > 0 && currList.get(i) == currList.get(i - 1)) {
                continue;
            }
            list.add(currList.get(i));
            permutationHelper(lists, permutations, list, idx + 1);
            list.remove(list.size() - 1);
        }
    }

    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>(); list1.add(1); list1.add(2); list1.add(3); list1.add(4);
        List<Integer> list2 = new ArrayList<>(); list2.add(11); list2.add(22); list2.add(33);
        List<Integer> list3 = new ArrayList<>(); list3.add(111); list3.add(222);
        List<List<Integer>> lists = new ArrayList<>(); lists.add(list1); lists.add(list2); lists.add(list3);
        generateUniqueListPermutations(lists);
    }
}

公共类列表置换{
公共静态列表generateUniqueListPermutations（列表列表）{
列表置换=新的ArrayList（）；
if（lists==null | | lists.size（）==0）{
返回置换；
}
//对每个输入列表进行排序
用于（列表：列表）{
集合。排序（列表）；
}
置换帮助器（列表、置换、新ArrayList（）、0）；
返回置换；
}
私有静态void置换帮助器（列表列表、列表置换、列表列表、int-idx）{
if（idx==lists.size（））{
添加（新数组列表（列表））；
返回；
}
List currList=lists.get（idx）；
对于（int i=0；i0&&currList.get（i）=currList.get（i-1））{
继续；
}
list.add（currList.get（i））；
置换助手（列表、置换、列表、idx+1）；
list.remove（list.size（）-1）；
}
}
公共静态void main（字符串[]args）{
list1=newarraylist（）；list1.add（1）；list1.add（2）；list1.add（3）；list1.add（4）；
list2=newarraylist（）；list2.add（11）；list2.add（22）；list2.add（33）；
List list3=newarraylist（）；list3.add（111）；list3.add（222）；
List lists=new ArrayList（）；lists.add（list1）；lists.add（list2）；lists.add（list3）；
generateUniqueListPermutations（列表）；
}
}

这个问题可以递归解决。算法非常简单，唯一棘手的部分是当列表中有重复的数字时避免重复排列。这样做的一个好方法是对每个列表进行排序，因此当从每个列表中选取整数时，很容易判断是否选取了特定的数字。下面是以您提供的示例作为测试用例的实现。您可以将列表的值更改为包含重复的数字，并查看输出不包含重复的排列

public class ListPermutation {
    public static List<List<Integer>> generateUniqueListPermutations(List<List<Integer>> lists) {
        List<List<Integer>> permutations = new ArrayList<>();
        if(lists == null || lists.size() == 0) {
            return permutations;
        }
        //sort each input list
        for(List<Integer> list : lists) {
            Collections.sort(list);
        }
        permutationHelper(lists, permutations, new ArrayList<>(), 0);
        return permutations;
    }
    private static void permutationHelper(List<List<Integer>> lists, List<List<Integer>> permutations, List<Integer> list, int idx) {
        if(idx == lists.size()) {
            permutations.add(new ArrayList<>(list));
            return;
        }
        List<Integer> currList = lists.get(idx);
        for(int i = 0; i < currList.size(); i++) {
            if(i > 0 && currList.get(i) == currList.get(i - 1)) {
                continue;
            }
            list.add(currList.get(i));
            permutationHelper(lists, permutations, list, idx + 1);
            list.remove(list.size() - 1);
        }
    }

    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>(); list1.add(1); list1.add(2); list1.add(3); list1.add(4);
        List<Integer> list2 = new ArrayList<>(); list2.add(11); list2.add(22); list2.add(33);
        List<Integer> list3 = new ArrayList<>(); list3.add(111); list3.add(222);
        List<List<Integer>> lists = new ArrayList<>(); lists.add(list1); lists.add(list2); lists.add(list3);
        generateUniqueListPermutations(lists);
    }
}

公共类列表置换{
公共静态列表generateUniqueListPermutations（列表列表）{
列表置换=新的ArrayList（）；
if（lists==null | | lists.size（）==0）{
返回置换；
}
//对每个输入列表进行排序
用于（列表：列表）{
集合。排序（列表）；
}
置换帮助器（列表、置换、新ArrayList（）、0）；
返回置换；
}
私有静态void置换帮助器（列表列表、列表置换、列表列表、int-idx）{
if（idx==lists.size（））{
添加（新数组列表（列表））；
返回；
}
List currList=lists.get（idx）；
对于（int i=0；i0&&currList.get（i）=currList.get（i-1））{
继续；
}
list.add（currList.get（i））；
置换助手（列表、置换、列表、idx+1）；
list.remove（list.size（）-1）；
}
}
公共静态void main（字符串[]args）{
list1=newarraylist（）；list1.add（1）；list1.add（2）；list1.add（3）；list1.add（4）；
list2=newarraylist（）；list2.add（11）；list2.add（22）；list2.add（33）；
List list3=newarraylist（）；list3.add（111）；list3.add（222）；
List lists=new ArrayList（）；lists.add（list1）；lists.add（list2）；lists.add（list3）；
generateUniqueListPermutations（列表）；
}
}

您是在寻找通用方法还是最终实现？您需要

L1、L2、L3

的笛卡尔积。可以递归完成。@NicoHaase两者都被接受。您是在寻找通用方法还是最终实现？您需要

L1、L2、L3

的笛卡尔积。可以递归完成。@这两个都被接受。