数组分割使子数组和接近

题目

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

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

错误分析

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

$$s[i,j]=\left\{\begin{array}{ll} 0, & i=0\ or\ j=0\\ \textrm{max}(s[i-1,j],s[i-1,j-array[i]]+array[i]), & 1\le i\le n,1\le j\le \frac{sum}{2} \end{array}\right.$$

代码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\le i$，原问题就是$s[n,\displaystyle\frac{n}{2},\frac{sum}{2}]$。同样按照第$i$个元素是否放入背包，递归式可以表示为

$$s[i,j,k]=\left\{\begin{array}{ll} 0, & i=0\ or\ j=0\ or\ k=0\\ \textrm{max}(s[i-1,j,k],s[i-1,j-1,k-array[i]]+array[i]), & 1\le i\le n,1\le j\le \frac{n}{2},1\le k\le \frac{sum}{2},j\le i \end{array}\right.$$

这样我们就成功的把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));
    }
}