动态行列排列组合实现

动态行列排列组合实现，算法可以尝试下
问题如图

img

代码如下

public static void main(String[] args) {
List aStrings = Arrays.asList("1");
List bStrings = Arrays.asList("2","3");
List cStrings = Arrays.asList("4","5", "6");

    /**
     * 动态行列排列组合题
     * 组合中间用_链接，打印最终组合List<String>，算法中不要出现固定行数和列数限制，结果如下（换行忽略）
     * 1_2, 1_3, 1_4, 1_5, 1_6,
     * 2_4, 2_5, 2_6,
     * 3_4, 3_5, 3_6,
     * 1_2_4, 1_2_5, 1_2_6,
     * 1_3_4, 1_3_5, 1_3_6
     */

}


import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        String[][] datas = new String[][]{
                new String[]{"1"},
                new String[]{"2", "3"},
                new String[]{"4", "5", "6"}
        };
        List<String> result = new ArrayList<>();
        dfs(datas, 0, "", result);
        System.out.println(result);
        result.sort((o1, o2) -> {
            int o1c = strCount(o1, '_');
            int o2c = strCount(o2, '_');
            if (o1c == o2c) {
                return o1.compareTo(o2);
            } else {
                return o1c - o2c;
            }
        });
        System.out.println(result);
    }

    public static int strCount(String source, char c) {
        int ans = 0;
        for (char sc : source.toCharArray()) {
            if (sc == c) {
                ans += 1;
            }
        }
        return ans;
    }

    public static void dfs(String[][] datas, int line, String prefix, List<String> result) {
        if (line >= datas.length) {
            return;
        }
        // 将这行加入结果集
        for (String str : datas[line]) {
            if ("".equals(prefix)) {
                dfs(datas, line + 1, str, result);
            } else {
                String newStr = prefix + "_" + str;
                result.add(newStr);
                dfs(datas, line + 1, newStr, result);
            }
        }
        // 抛弃这行
        dfs(datas, line + 1, prefix, result);
    }
}

用的是dfs，
你给的样例打印顺序挺不合理的，看起来顺序是按照个数排序，但是遍历1开头2个结束后，再重新遍历1开头3个感觉是冗余的操作。所以我只能重新写了一个排序。但是我这个排序只是随便写写不作数的，还是需要你把问题补充完整

那我来对模型的兼容性扩展下（支持多个数组）


package project;

import java.util.*;

/**
 * @author Lenovo
 */
public class Solution {

    public static TreeSet<String> resList = new TreeSet<>();

    public void helper(List<List<String>>lists, int layer, String path) {
        int size;
        if(layer<0||layer>= (size=lists.size())){
            return;
        }
        for(String p:lists.get(layer)){
            if(!"".equals(path)) {
                resList.add(path+"_"+p);
                helper(lists, layer + 1, path+"_"+p);
            }else{
                helper(lists, layer + 1,  p);
            }
        }
        for(int i=layer+1;i<size;i++){
            helper(lists, i, path);
        }
    }

    public static void main(String[] args) {
        List<String> aStrings = Arrays.asList("1");
        List<String> bStrings = Arrays.asList("2", "3");
        List<String> cStrings = Arrays.asList("4", "5", "6");
        List<String> dStrings = Arrays.asList("7", "8", "9","10");
        List<List<String>>lists = Arrays.asList(aStrings, bStrings, cStrings,dStrings);
        Solution s = new Solution();
     
        s.helper(lists, 0, "");
    
        List<String>res = new ArrayList<>(resList);
        Collections.sort(res, (o1,o2)->{
            String[]param1 = o1.split("_");
            String[]param2 = o2.split("_");
            int idx1 = param1.length,
                    idx2 = param2.length,
                    idx=0;
            if(idx1!=idx2) {
                return idx1>idx2?1:-1;
            }
            while(idx < idx1){
                Integer i1 = Integer.parseInt(param1[idx]);
                Integer i2 = Integer.parseInt(param2[idx++]);
                if(i1.equals(i2)){
                    continue;
                }
                return i1.compareTo(i2);
            }
            return 0;
        });
        System.out.println(res);
    }
}

行数不固定你把参数弄成二维数组，不然三个一维数组/列表参数怎么不固定行？

看示例中最后一行的组合算法与上面的不一样？详细的规则是什么？

如果不要求顺序，你可以这样写：

img

如果要求保证顺序，你可以这样写：

img