数组分割使子数组和接近

题目

描述1：一个无序且长度为偶数的正整数数组，要求将它分割成为两个长度相等的子数组，且这两个子数组的和最接近。输入数组的长度和相应的元素，输出两个子数组各自元素之和。
描述2：两个长度相等的数组，要求将它们的元素互换，使得这两个数组的和最接近。

• 测试输入
  10
  1 5 7 8 9 6 3 11 20 17
• 测试输出
  43 44

错误分析

设数组所有元素之和为 sum ，要让分割的两个子数组的和最接近，相当于让它们的和都接近于 sum2 ，我们不妨考虑和偏小的子数组。这貌似一个典型的0-1背包问题，原问题就是要问对于一个大小为 sum2 的背包，要选取哪些元素能尽可能装满背包。定义数组 array[i] ， i=1∼n ， s[i,j] 表示前 i 个元素放入总容量为 j 的背包所占有的最大容量，原问题就是 s[n,sum2] 。按照第 i 个元素是否放入背包，递归式可以表示为

s[i,j]=⎧⎩⎨0,max(s[i−1,j],s[i−1,j−array[i]]+array[i]),i=0 or j=01≤i≤n,1≤j≤sum2

代码1

import java.util.Scanner;

public class ArraySplit {
    static void wrongSolution(int[] array, int[][] s, int n, int sum) {
        for (int i = 0; i < sum / 2 + 1; i++) {
            s[0][i] = 0;
        }
        s[1][0] = 0;
        for (int i = 1; i < n + 1; i++) {
            for (int j = 1; j < sum / 2 + 1; j++) {
                int skipi = s[(i - 1) % 2][j];
                int takei = j < array[i - 1] ? 0 : 
                    s[(i - 1) % 2][j - array[i - 1]] + array[i - 1];
                s[i % 2][j] = Math.max(takei, skipi);
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] array = new int[n];
        int sum = 0;
        for (int i = 0; i < n; i++) {
            array[i] = sc.nextInt();
            sum += array[i];
        }
        int[][] s = new int[2][sum / 2 + 1];
        solution(array, s, n, sum);
        int left = s[n % 2][sum / 2];
        System.out.println(left + " " + (sum - left));
    }
}

写完代码发现结果有问题，这是因为我们少用了题目中的一个条件，也是最为重要的条件，即“分割成为两个长度相等的子数组”，这样的话结果正确才怪。

正确分析

我们不着急完全推翻之前的做法，只是分析一下本题和经典的0-1背包问题有什么差别。经典的0-1背包问题并没有限制选取元素的个数，只是要求尽量装满背包；本题则在尽量装满背包的前提下，要求选取的元素和剩下的元素个数相等。这样仅仅利用 s[i,j] 来记录状态是不能保证选取了多少元素的，因此需要多一个维度来记录选取元素的个数，即定义 s[i,j,k] 表示前 i 个元素选取 j 个元素，放入总容量为 k 的背包所占有的最大容量，其中 j≤i ，原问题就是 s[n,n2,sum2] 。同样按照第 i 个元素是否放入背包，递归式可以表示为

s[i,j,k]=⎧⎩⎨0,max(s[i−1,j,k],s[i−1,j−1,k−array[i]]+array[i]),i=0 or j=0 or k=01≤i≤n,1≤j≤n2,1≤k≤sum2,j≤i

这样我们就成功的把0-1背包问题扩展到了限制元素个数的0-1背包问题，背包中的元素个数不仅可以设置为总元素个数的一半，还可以是小于总个数的任意数。

代码2

import java.util.Scanner;

public class ArraySplit {
    static void solution(int[] array, int[][][] s, int n, int sum) {
        for (int i = 0; i < sum / 2 + 1; i++) {
            s[0][0][i] = 0;
            s[1][0][i] = 0;
        }
        for (int i = 0; i < n / 2 + 1; i++) {
            s[0][i][0] = 0;
            s[1][i][0] = 0;
        }
        for (int i = 1; i < n + 1; i++) {
            int maxj = Math.min(i, n / 2);
            for (int j = 1; j <= maxj; j++) {
                for (int k = 1; k < sum / 2 + 1; k++) {
                    int skipi = s[(i - 1) % 2][j][k];
                    int takei = k < array[i - 1] ? 0 : 
                        s[(i - 1) % 2][j - 1][k - array[i - 1]] + array[i - 1];
                    s[i % 2][j][k] = Math.max(takei, skipi);
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] array = new int[n];
        int sum = 0;
        for (int i = 0; i < n; i++) {
            array[i] = sc.nextInt();
            sum += array[i];
        }
        int[][][] s = new int[2][n / 2 + 1][sum / 2 + 1];
        solution(array, s, n, sum);
        int left = s[n % 2][n / 2][sum / 2];
        System.out.println(left + " " + (sum - left));
    }
}