排列】用数字0，1，2，3，4，5，6组成没有重复数字的四位数，其中个位、十位和百位上的数字之和为偶数的四位数共有几个？

【数学解法】

千位分两种情况：

当千位为135之一，假设为1，剩下023456给个十百位

若十百位为两奇数一偶数，则有C22C41A33；

若十百位为三偶数，则有C43A33;

当千位为246之一，假设为2，剩下013456给个十百位

若十百位为两奇数一偶数，则有C32C31A33；

若十百位为三偶数，则有C33A33;

所以，总数=3*（24+24+54+6）=3*108=324种

【程序解法】

思路：将0，1，2，3，4，5，6选4进行排列，去除掉首位为0和个十百位之和不是偶数的，剩下的就是结果。

主类EvenSum代码：

package test230501;

import test230429.Arranger;

import java.util.List;

/**
 * 用数字0，1，2，3，4，5，6组成没有重复数字的四位数，其中个位、十位和百位上的数字之和为偶数的四位数共有几个？
 */
public class EvenSum {
    public static void main(String[] args){
        int[] numbers = {0,1, 2, 3, 4,5,6};
        Arranger arranger = new Arranger(numbers,4);

        int idx = 0;
        for (List<Integer> re : arranger.getResults()) {
            // 去掉千位为0的情况
            if(re.get(0)==0){
                continue;
            }

            // 去掉百十个三位和为奇数的情况
            int sum=re.get(1)+re.get(2)+re.get(3);
            if((sum % 2)==1){
                continue;
            }

            System.out.println(String.format("%02d", ++idx) + "." + re.get(0)+re.get(1)+re.get(2)+re.get(3));
        }
    }
}

辅助类Arranger：

package test230429;

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

/**
 * 用于产生排列结果的工具类
 * 从n个元素中取出m个元素，按照一定的顺序排成一列。得到所有排列的方案
 */
public 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