任意2n个整数，从其中选出n个整数，使得选出的n个整数和同剩下的n个整数之和的差最小

解题参考原文如下（请带着批判的眼光去看，有些细节我认为是不对的，但是我没有改动）：

<编程之美>数组分割问题

题目概述：有一个没有排序，元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组，并使两个子数组的和最接近。
假设数组A[1..2N]所有元素的和是SUM。模仿动态规划解0-1背包问题的策略，令S(k, i)表示前k个元素中任意i个元素的和的集合。显然：

S(k, 1) = {A[i] | 1<= i <= k}
S(k, k) = {A[1]+A[2]+…+A[k]}
S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }

按照这个递推公式来计算，最后找出集合S(2N, N)中与SUM最接近的那个和，这便是答案。这个算法的时间复杂度是O(22N).
因为这个过程中只关注和不大于SUM/2的那个子数组的和。所以集合中重复的和以及大于SUM/2的和都是没有意义的。把这些没有意义的和剔除掉，剩下的有意义的和的个数最多就是SUM/2个。所以，我们不需要记录S(2N,N)中都有哪些和，只需要从SUM/2到1遍历一次，逐个询问这个值是不是在S(2N,N)中出现，第一个出现的值就是答案。我们的程序不需要按照上述递推公式计算每个集合，只需要为每个集合设一个标志数组，标记SUM/2到1这个区间中的哪些值可以被计算出来。关键代码如下：

for(i = 0; i < N+1; i++)  
    for(j = 0; j < sum/2+1; j++)  
        flag[i][j] = false;  
flag[0][0] = true;  
for(int k = 1; k <= 2*N; k++) {  
    for(i = k > N ? N : k; i >= 1; i--) {  
        //两层外循环是遍历集合S(k,i)  
        for(j = 0; j <= sum/2; j++) {  
            if(j >= A[k] && flag[i-1][j-A[k]])  
                flag[i][j] = true;  
        }  
    }  
}  
for(i = sum/2; i >= 0; i--) {  
    if(flag[N][i]) {  
        cout << "minimum delta is " << abs(2*i - sum) << endl;  
        break;  
    }  
} 

---

正文

如果上面的内容你看懂了，那么万事大吉。你可以关闭网页了。
像我一样不够聪明的人，跟着我的思路往下看吧。

解题思路：

2N个整数，分成2组，使和之差最小。设2N个整数的和是NUM。
关键点：让N个整数的和最接近NUM/2，那么显然另外N个整数的和也是最接近NUM/2，显然这种情况和之差是最小的。

公式

依然是上面的公式。
令S(k, i)表示前k个元素中任意i个元素的和的集合。显然：
注意公式中的数组序号是按照常规思路，从1开始的。

S(k, 1) = {A[i] | 1<= i <= k}
S(k, k) = {A[1]+A[2]+…+A[k]}
S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }

看不懂？举个例子就好懂了。
设A[] = {1, 2, 3, 4, 5, 6, 7, 8};

S(3, 1) = {1，2，3};
// S(3, 3)：在前三个数中任意选择三个数
S(3, 3) = {1+2+3} = {6};
// S(4, 3)：在前四个数中任意选择三个数
// 相比S(3, 3)多了哪几种情况呢
/* 首先S(4, 3)集合肯定是包含S(3, 3)的，另外还多出来A[4]分别替换掉A[1]、A[2]、A[3]的情况，即{4+2+3,1+4+3,1+2+4} = {7, 8, 9}*/
// 观察规律，{2+3,1+3,1+2}=S(3, 2)集合，于是得到上面的公式
S(4, 3) = S(3, 3) U {4 + x | x属于S(3, 2) = {6, 7, 8, 9};

算法设计

源码来源
针对源代码，继续解释。

public class Main {
    // 题目：任意2n个整数，从其中选出n个整数，使得选出的n个整数和同剩下的n个整数之和的差最小。
    public static void main(String[] args) {
        int A[] = { 1, 2, 3, 5, 7, 8, 9 };
        // int A[] = { 1, 5, 7, 8, 9, 6, 3, 11, 20, 17 };
        func(A);
    }

    static void func(int A[]) {
        int i;
        int j;
        // 下面的变量声明地很直白，不解释
        int n2 = A.length;
        int n = n2 / 2;
        int sum = 0;
        // 计算数组总和
        for (i = 0; i < A.length; i++) {
            sum += A[i];
        }

        /*还记得编程之美中的话吗？
        我们的程序不需要按照上述递推公式计算每个集合，只需要为每个集合设一个标志数组，标记SUM/2到1这个区间中的哪些值可以被计算出来。
        flag[i][j]:任意i个整数之和是j,则flag[i][j]为true。换言之，flag[i][j]为true，那么一定能找到一组整数，使它们的和是j。
        下面的代码将对flag数组进行初始化*/
        boolean flag[][] = new boolean[A.length + 1][sum / 2 + 1];
        for (i = 0; i < A.length; i++)
            for (j = 0; j < sum / 2 + 1; j++)
                flag[i][j] = false;

        flag[0][0] = true;
        // 重点来了
        for (int k = 0; k < n2; k++) {
            //i取k和n中的较小值，我们的目的是找出集合S(2N, N)中与SUM最接近的那个和，所以k>n时，取到n就足够了。k<n时，我们显然无法从3个数中任意选择4个数，所以取k值
            for (i = k > n ? n : k; i >= 1; i--) {
                // 两层外循环是遍历集合S(k,i)，遍历顺序S[1][1],S[2][2],S[2][1],S[3][3]……特殊的依赖关系导致必须这样设计算法
                // 内层循环计算将A[k]加入到集合中能取到的可能的j值
                for (j = 0; j <= sum / 2; j++) {//j是i个任意整数可能的和，从0遍历到sum / 2，判断能否得到
                    // 得到j值的条件，j是和，A[k]只是其中一个，肯定需要j >= A[k]，否则，取flag[i - 1][j - A[k]]的值的时候会发生越界情况。flag[i - 1][j - A[k]] = true代表可以找到i - 1个数，使它们的和为j - A[k]，所以此条件满足时意味着flag[i][j] = true
                    if (j >= A[k] && flag[i - 1][j - A[k]])
                        flag[i][j] = true;
                }
            }
        }
        // 终于计算完了，现在找到最合适的结果就好了，要找到最接近SUM / 2的和，倒着找最好了
        for (j = sum / 2; j >= 0; j--) {
            if (flag[n][j]) {
                System.out.println("sum is " + sum);
                System.out.println("sum/2 is " + sum / 2);
                System.out.println("j is " + j);
                System.out.println("minimum delta is " + Math.abs(2 * j - sum));
                break;
            }
        }
    }
}

运行结果：

sum is 35
sum/2 is 17
j is 17
minimum delta is 1