暴力递归转动态规划（十六）

题目
给定一个正数数组arr，
请把arr中所有的数分成两个集合，尽量让两个集合的累加和接近
返回：最接近的情况下，较小集合的累加和。
注：只要求两个集合的累加和最接近情况下较小的一个，不要求两个集合个数相同或相近。

暴力递归
这道题其实和之前说过的背包问题是一样的逻辑。
让两个集合的累加和相近的方法就是求出老数组累加和的一半。并在遍历数组的过程中以此条件作为基准，如果加上当前数后，累加和大于数组一半的值，那这个数就舍弃不要。否则就加上这个数。继续向下递归。

代码
因为求的是所有数的累加和 小于 老数组的一半，所以要取Math.max(p1,p2)。目的是找出最接近老数组一半的累加和。

 public static int right(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return process(arr, 0, sum / 2);
    }

    public static int process(int[] arr, int index, int rest) {
        if (index == arr.length) {
            return 0;
        } else {
            //背包问题，这个数可能要，也可能不要
            int p1 = process(arr, index + 1, rest);
            //这个数如果要，就不能大于剩余数值
            int p2 = 0;
            if (arr[index] <= rest) {
                p2 = arr[index] + process(arr, index + 1, rest - arr[index]);
            }
            return Math.max(p1, p2);
        }
    }

动态规划
写出了尝试的暴力递归方法后，动态规划方法就相对简单。

1. 根据暴力递归方法中的可变参数来确定dp表的范围（index可到达arr.length ， rest可到达 0 ）。
2. 根据暴力递归方法中base case来填充dp表默认值（这道题中是 index = arr.length，return 0），而int[] 创建后，每个格子的初始化默认值就是0，所以不用额外处理。
3. 根据暴力递归代码中的依赖关系写循环，无论当前值要不要 index都 + 1，如果要p2,则rest - arr[index]。 所以可以确定 index是依赖关系是从尾端到0（arr.length ~ 0），而rest依赖是从 0 ~ arr的累加和 / 2。
   所以填充index要从arr.length 向 0遍历，rest从0 向 arr遍历。
   因为这道题在填充dp表的每个格子时没有枚举行为（for循环），所以到这步就可以了。

代码

 public static int dp(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        int N = arr.length;
        int M = sum / 2;
        int[][] dp = new int[N + 1][M + 1];

        for (int index = N - 1; index >= 0; index--) {
            for (int rest = 0; rest <= M; rest++) {
                int p1 = dp[index + 1][rest];
                //这个数如果要，就不能大于剩余数值
                int p2 = 0;
                if (arr[index] <= rest) {
                    p2 = arr[index] + dp[index + 1][rest - arr[index]];
                }
                dp[index][rest] = Math.max(p1, p2);
            }
        }
        return dp[0][M];
    }

题目
题目2和上一道题类似，都是拆分数组后最接近的情况下，较小集合的累加和。不同的地方在于，这道题要求拆分的2个集合长度相同。具体题目如下：
给定一个正数数组arr，请把arr中所有的数分成两个集合
如果arr长度为偶数，两个集合包含数的个数要一样多
如果arr长度为奇数，两个集合包含数的个数必须只差一个
请尽量让两个集合的累加和接近
返回：最接近的情况下，较小集合的累加和。

暴力递归
整体思路大致和上面相同，不过因为这道题需要考虑到集合的元素个数，所以需要先判断arr中数组元素的奇偶。如果是偶数好说那就一半一半，但是如果是奇数个，那要看 arr.length / 2 和 ( arr.length / 2 ) + 1这两个哪个是最接近集合中较大的一个。（因为依然是以老数组的总和一半作为边界条件），所以在最接近的情况下，取arr.length / 2 和 ( arr.length / 2 ) + 1中较大的那一个。

代码
获取老数组的长度后，递归过程中一定要选取足够数量的元素。奇数情况要考虑到 N / 2 和 (N / 2) + 1情况哪个更大。

 public static int right(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        int N = arr.length;
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }

        if (N % 2 == 0) {
            return process(arr, sum / 2, 0, N / 2);
        } else {
            return Math.max(process(arr, sum / 2, 0, N / 2), process(arr, sum / 2, 0, (N / 2) + 1));
        }
    }

    //返回从arr[index...]位置开始 选择picks个，最接近rest的累加和。
    public static int process(int[] arr, int rest, int index, int picks) {
        if (index == arr.length) {
            return picks == 0 ? 0 : -1;
        } else {
            int p1 = process(arr, rest, index + 1, picks);

            int p2 = -1;
            int next = -1;
            if (arr[index] <= rest) {
                next = process(arr, rest - arr[index], index + 1, picks - 1);
            }

            if (next != -1) {
                p2 = next + arr[index];
            }
            return Math.max(p1, p2);
        }
    }

动态规划
根据暴力递归改写动态规划，暴力递归中共有3个可变参数，所以dp表是个三维数组。
其中参数picks的范围，因为要考虑到arr.length的奇偶，所以再初始化时，让arr.length + 1后再除2。这样向下取整后，就算是奇数个的长度也可以适配。
但是最后算的时候记着将M - 1。

 public static int dp(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        int N = arr.length;

        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        sum /= 2;

        int M = (N + 1) / 2;
        int[][][] dp = new int[N + 1][sum + 1][M + 1];

        for (int index = 0; index <= N; index++) {
            for (int rest = 0; rest <= sum; rest++) {
                for (int picks = 1; picks <= M; picks++) {
                    dp[index][rest][picks] = -1;
                }
            }
        }

        for (int index = N - 1; index >= 0; index--) {
            for (int rest = 0; rest <= sum; rest++) {
                for (int picks = 1; picks <= M; picks++) {
                    int p1 = dp[index + 1][rest][picks];

                    int p2 = -1;
                    int next = -1;
                    if (arr[index] <= rest) {
                        next = dp[index + 1][rest - arr[index]][picks - 1];
                    }

                    if (next != -1) {
                        p2 = next + arr[index];
                    }
                    dp[index][rest][picks] = Math.max(p1, p2);
                }
            }
        }

        if (N % 2 == 0) {
            return dp[0][sum][M];
        } else {
            return Math.max(dp[0][sum][M - 1], dp[0][sum][M]);
        }
    }