java组合排列模板

个人在刷算法题的过程中，遇到排列组合问题总结出以下解决方案

1. 无重复元素的数组，求全排列；
2. 有重复元素的数组，求全排列；
3. 无重复元素的数组，求组合【子集】；
4. 有重复元素的数组，求组合；
   以上四类题，可以用统一的模板实现，如下所示：

1.全排列

问题1：求{1，3，4，6，7，8}的全排列
1、无重复元素
代码

public class Permutation{
    static boolean[] a = new boolean[100]; //数组占位思想  a[1]=1   判断数字1是否被选过

    public static void main(String[] args) {
        Arrays.fill(a, false);  //给a数组全部赋值为boolean
        int[] input = {1, 3, 4, 6, 7, 8};
        int[] output = new int[6];
        dfs(input, output, 0);
    }

    public static void dfs(int[] input, int[] output, int k) {
        if (k == input.length) {           //当前取的的第k个值  k为最后一个值时输出
            for (int i = 0; i < output.length; i++) {
                System.out.print(output[i]); //输出每次排列的结果
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < input.length; i++) { //枚举各种状态
            if (a[i]) {      //前面已经选择了i    剪枝
                continue;
            }
            a[i] = true;     //占位 为剪枝而作准备
            output[k] = input[i];  //记录当前第k个选的具体数值
            dfs(input, output, k + 1);   //递归调用寻找下一个
            a[i] = false;     // 复位 （清零）    回溯
        }
    }
}

2、 有重复元素
代码

public class Permutation{
    static boolean[] a = new boolean[100]; //数组占位思想  a[1]=1   判断数字1是否被选过

    public static void main(String[] args) {
        Arrays.fill(a, false);  //给a数组全部赋值为boolean
        int[] input = {1, 3, 4, 6, 7, 8};
        int[] output = new int[6];
        dfs(input, output, 0);
    }

    public static void dfs(int[] input, int[] output, int k) {
        if (k == input.length) {           //当前取的的第k个值  k为最后一个值时输出
            for (int i = 0; i < output.length; i++) {
                System.out.print(output[i]); //输出每次排列的结果
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < input.length; i++) { //枚举各种状态
            output[k] = input[i];  //记录当前第k个选的具体数值
            dfs(input, output, k + 1);   //递归调用寻找下一个
        }
    }
}

2.组合

问题2：从集合{1，3，4，6，7，8}中选4个元素有多少中结果
1、.元素不能重复

选取四个元素，即求解C(6,4)时，先按序号从数组中顺序取出一个元素，再在取出的元素后面的元素中选取一个元素。详细如下：
第一步：a.选取{1} b.在{1，3，4，6，7，8}中求解C(6,1);
第二步：a.选取{3} b.在{3，4，6，7，8}中求解C(5,1);
第三步：a.选取{4} b.在{4，6，7，8}中求解C(4,1);
第四步：a.选取{6} b.在{6，7，8}中求解C(3,1); 此时已经选了四个 结束
代码：

public class combination {
    static boolean [] a=new boolean[100];   //数组占位思想  a[1]=1   判断数字1是否被选过
    public static void main(String[] args) {
        Arrays.fill(a,false);         //给a数组全部赋值为boolean
        int [] output=new int[4];          //组合好后的数组；
        int [] input={1,3,4,6,7,8};
        dfs(input,output,0,4);   //4 表示要选择多少个元素
    }
    public static void dfs(int [] input,int [] output,int k,int targe){
        if(k==targe){
            System.out.println(Arrays.toString(output)); //k表示已经选了几个元素，选满了4个就输出
            return;
        }
        for (int i =0; i <input.length; i++) {      //枚举各种状态  
            if(a[i]) {              //前面已经选择了i    剪枝
                continue;
            }
            a[i]=true;               //占位 为剪枝而作准备
            output[k]=input[i];      //记录当前第k个选的具体数值
            dfs(input,output,k+1,targe);    //递归调用寻找下一元素
            a[i]=false;              // 复位 （清零）    回溯
        }
    }
}

2、元素可以重复
选取四个元素，即求解C(6,4)时，先按序号从数组中顺序取出一个元素，再在取出的元素后面的元素中选取一个元素。详细如下：
第一步：a.选取{1} b.在{1，3，4，6，7，8}中求解C(6,1);
第二步：a.选取{3} b.在{1，3，4，6，7，8}中求解C(6,1);
第三步：a.选取{4} b.在{1，3，4，6，7，8}中求解C(6,1);
第四步：a.选取{6} b.在{1，3，4，6，7，8}中求解C(6,1); 此时已经选了四个 结束
代码：

public class combination  {
    static boolean[] a = new boolean[100]; //数组占位思想  a[1]=1   判断数字1是否被选过
    public static void main(String[] args) {
        Arrays.fill(a, false);  //给a数组全部赋值为boolean
        int[] input = {1, 3, 4, 6, 7, 8};
        int[] output = new int[4];
        dfs(input, output, 0,4);
    }

    public static void dfs(int[] input, int[] output, int k, int targe) {
        if (k ==targe) {           //当前取的的第k个值  k为最后一个值时输出
            for (int i = 0; i < output.length; i++) {
                System.out.print(output[i]); //输出每次排列的结果
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < input.length; i++) { //枚举各种状态
            output[k] = input[i];  //记录当前第k个选的具体数值
            dfs(input, output, k + 1,targe);   //递归调用寻找下一个
        }
    }
}

总结：有重复和无重复就是用一个布尔型数组标记一下就可以，组合就是6选4这种类型，然后全排列就是全部都要选