【Java与排列组合】某年高考选择题：1，3，5，7，9中选两个，0，2，4，6，8中选两个，组成的无重复四位数有几个？

admin • 2024-03-21 20:51 • 5G

【题解】

某年某地高考卷选择题中有这么一道排列组合题，那就是问：从1，3，5，7，9中选两个数，从0，2，4，6，8中选两个数，组成的无重复四位数有几个？

这道题的两个条件中，无重复是无效的，因为两次五选二都不会出现重复的情况，

四位数则是重要的，这个条件明示了要把0排在首位的情况排除掉。

顺着这个思路，可以先把所有情况列出：C_5_2*C_5_2*A_4_4=2400种（注意C_5_2代表五选二，A_4_4代表四个数全排列）

把0硬放在首位，然后五选二，四选一，再三个数全排列有：C_5_2*C_4_1*A_3_3=240种，

总个数减去需要排除的数就是2400-240=2160种。

【程序解法】

从1，3，5，7，9中选两个数，从0，2，4，6，8中选两个数，四个数进行全排列，然后排除掉首位是0的情况。

【Java代码】

主类：

package test240318;

import java.util.List;

/**
 * 从1，3，5，7，9中选两个数，从0，2，4，6，8中选两个数，组成的无重复四位数有几个？
 * @author ufo
 *
 */
public class Test240318 {
    public static void main(String[] args) {
        final int[] arr1= {1,3,5,7,9};
        Combination cbnt1=new Combination(arr1,2);
        List<List<Integer>> list1=cbnt1.getResults();
        
        final int[] arr2= {0,2,4,6,8};
        Combination cbnt2=new Combination(arr2,2);
        List<List<Integer>> list2=cbnt2.getResults();
        
        int idx=0;
        for(List<Integer> ls1:list1) {
            for(List<Integer> ls2:list2) {
                int[] arr= {ls1.get(0),ls1.get(1),ls2.get(0),ls2.get(1)};
                Arranger arranger = new Arranger(arr);
                
                for (List<Integer> ls : arranger.getResults()) {
                    int head=ls.get(0);
                    if(head!=0) {// 去掉0在首位的方案
                        String sentence=String.format("%02d. ", ++idx);
                        sentence+=ls.get(0)+"";
                        sentence+=ls.get(1)+"";
                        sentence+=ls.get(2)+"";
                        sentence+=ls.get(3);
                        System.out.println(sentence);
                    }
                }
            }
        }
    }
}

组合器类：

package test240318;

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

/**
 * 数学中排列组合中的组合器实现
 * 传入一个数组及选择的个数，传出所有选择方案
 */
class Combination {
    /**
     * 用于存放中间结果
     */
    private Stack<Integer> stack;
    
    /**
     * 用于存放结果
     */
    private List<List<Integer>> results;
    
    /**
     * 构造函数
     * @param arr 进行组合的元素
     * @param count 选多少个
     */
    public Combination(int[] arr,int count) {
        if(count>arr.length) {
            throw new ArrayIndexOutOfBoundsException(count+">"+arr.length);
        }
        
        stack = new Stack<>();
        results=new ArrayList<>();
        doSelect(arr,count,0,0);
    }
    
    /**
     * 进行选择
     * @param arr 目标数组
     * @param expect 期望选择数量
     * @param actual 实际选择数量
     * @param current 当前下标
     */
    private void doSelect(int[] arr, int expect, int actual, int current) {
        if(actual == expect) {
            List<Integer> list=new ArrayList<>();
            
            for(int i:stack) {
                list.add(i);
            }
            
            results.add(list);
            
            return;
        }
         
        for(int i=current;i<arr.length;i++) {
            if(!stack.contains(arr[i])) {
                stack.add(arr[i]);
                doSelect(arr, expect, actual+1, i);
                stack.pop();
            }
        }
    }
    
    /**
     * 取得组合结果
     * @return
     */
    public List<List<Integer>> getResults(){
        return results;
    }
    
    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        final int[] arr= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
        final int count=2;
        
        Combination c=new Combination(arr,count);
        List<List<Integer>> results=c.getResults();
        
        int idx=0;
        for(List<Integer> res:results) {
            System.out.println(String.format("%02d", ++idx) +"."+res);
        }
    }
}

排列器类：

package test240318;

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

/**
 * 用于产生排列结果的工具类
 * 从n个元素中取出m个元素，按照一定的顺序排成一列。得到所有排列的方案
 */
class Arranger {
    // 保存在内部的对原始元素数组的引用
    private int[] arr;

    // 总计多少元素，此即数组长度
    private final int n;

    // 选多少个
    private final int m;

    // 返回结果
    private List<List<Integer>> results;

    /**
     * 构造函数一
     * 这个构造函数是用于全排列的（n=m=数组长度）
     *
     * @arr 原始元素数组
     */
    public Arranger(int[] arr) {
        this.arr = arr;
        this.n = arr.length;
        this.m = arr.length;

        this.results = new ArrayList<>();
        doArrange(new ArrayList<>());
    }

    /**
     * 构造函数二
     * 这个构造函数是用于部分排列的(m<n=数组长度)
     *
     * @param arr    原始元素数组
     * @param selCnt 选多少个
     */
    public Arranger(int[] arr, int selCnt) {
        this.arr = arr;
        this.n = arr.length;
        this.m = selCnt;
        if (m > n) {
            throw new ArrayIndexOutOfBoundsException("m:" + m + " >n:" + n);
        }

        this.results = new ArrayList<>();
        doArrange(new ArrayList<>());
    }

    /**
     * 使用递归进行全排列，结果放在results中
     *
     * @param initialList 初始链表
     */
    private void doArrange(List<Integer> initialList) {
        List<Integer> innerList = new ArrayList<>(initialList);

        if (m == initialList.size()) {
            results.add(innerList);
        }

        for (int i = 0; i < arr.length; i++) {
            if (innerList.contains(arr[i])) {
                continue;
            }

            innerList.add(arr[i]);
            doArrange(innerList);
            innerList.remove(innerList.size() - 1);
        }
    }

    /**
     * 获得结果链表的引用
     *
     * @return
     */
    public List<List<Integer>> getResults() {
        return results;
    }

    // 测试
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4};
        Arranger arranger = new Arranger(numbers);

        System.out.println("四元素全排列示例:");
        int idx = 0;
        for (List<Integer> re : arranger.getResults()) {
            System.out.println(String.format("%02d", ++idx) + "." + re);
        }

        /*Arranger arranger2 = new Arranger(numbers, 2);
        System.out.println("n四选二排列示例:");
        idx = 0;
        for (List<Integer> re : arranger2.getResults()) {
            System.out.println(String.format("%02d", ++idx) + "." + re);
        }*/
    }
}

【结果】

【结论】

传统解法和程序解法得到的数量是一致的，但传统解法败在只能求数量，程序解法胜在能把所有情况列出来。

END

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。

THE END

java 高考

二维码

AcWing 4405. 统计子矩阵（双指针，前缀和）

< <上一篇

GraphQL入门之变更（Mutation）操作

下一篇>>

搜索内容