等和子数组最小和

题目描述

给定一个数组nums，将元素分为若干个组，使得每组和相等，求出满足条件的所有分组中，组内元素和的最小值。输入描述第一行输入m接着输入m个数，表示此数组nums数据范围:1<=m<=50,1<=nums[i]<=50

输出描述

最小拆分数组和

用例

输入

7
4 3 2 3 5 2 1

输出

5

说明

可以等分的情况有：4个子集(5),(1,4), (2,3), (2,3)；

2个子集(5,1,4),(2,3,2,3)但最小的为5。

思路

先求出数组所有元素的和sum，如果数组可以被等分成若干组，那么子数组的和必然是sum的因数；若没办法等分，也就是只能分成1个子数组（就是原数组本身），那我们的结果就是sum。

所以第二步求出sum所有的因数。

第三步将所有的因数从低到高分别尝试，看这个因数是不是等和子数组最小和，如果是直接停止，得到答案。

在第三步的检查中使用递归方法进行遍历所有可能的选择。

代码实现

import java.util.ArrayList;
import java.util.Scanner;

class Main {

    //数组容器
    public static int[] nums;
    //数组选择记录
    public static boolean[] choose;
    //数组元素总和
    public static int sum;
    //搜索结果(sum是否可以被分为和为des的若干子数组)
    public static boolean falg = false;
    //满足条件的最小因数
    public static int minFactor;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int size = Integer.parseInt(in.nextLine());
        nums = new int[size];
        choose = new boolean[size];

        //获取数组和sum
        String[] strings = in.nextLine().split(" ");
        for (int i = 0; i < strings.length; i++) {
            nums[i] = Integer.parseInt(strings[i]);
            sum += nums[i];
        }

        //获取sum的因数(不需要sum自身)
        ArrayList<Integer> factors = new ArrayList<>();
        for (int i = 1; i <= sum/2; i++) {
            if (sum % i == 0) {
                factors.add(i);
            }
        }

        //可优化：有大于des的元素可以直接判定false

        //遍历由小到大寻找符合条件的因数
        falg = false;
        for (int i = 0; i < factors.size(); i++) {
            dfs(0, factors.get(i), 0, 0);
            if (falg) {
                minFactor = factors.get(i);
                break;
            }
        }
        //如果没有找到符合的因数，那么答案就是sum本身（只分一组）
        if (minFactor == 0) {
            minFactor = sum;
        }
        System.out.println(minFactor);
    }

    /**
     * 遍历各种组合判断是否可以按目标和分组
     * 调用之前应先验证目标元素可行（先验证des是sum的一个因数）
     * 至少两等分再调用，1等分不要调用，直接出结果
     * @param index 当前索引
     * @param des 子数组目标元素和
     * @param countI 当前子数组组号
     * @param countD 当前子数组当前元素和
     */
    public static void dfs(int index,int des,int countI,int countD) {
        //当本组元素和没达到目标时
        if (index < choose.length && !choose[index] && countD < des) {
            //选取当前元素
            choose[index] = true;
            dfs(index + 1, des, countI, countD + nums[index]);
            //不选取当前元素
            choose[index] = false;
            dfs(index + 1, des, countI, countD);
        } else if (countD == des) {//当恰好达到目标时
            //当倒数第二组组合完成，倒数第一组不需验证，直接通过
            if (countI == sum / des - 2) {
                falg = true;
            } else if (countI < sum / des - 2) {
                int start = -1;
                for (int i = 0; i < choose.length; i++) {
                    if (!choose[i]) {
                        start = i;
                        break;
                    }
                }
                if (start == -1) {
                    return;
                }
                dfs(start, des, countI + 1, 0);
            }
        }
    }

}

优化

本问题有一个可优化的地方，就是在检验一个因数是不是子数组最小和时，如果数组中有大于这个因数的数，那么这个因数一定不行，可以直接跳过。