通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小

32.
有两个序列a,b，大小都为n,序列元素的值任意整数，无序；
要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
例如: 
var a=[100,99,98,1,2, 3];
var b=[1, 2, 3, 4,5,40];

求解思路：
    当前数组a和数组b的和之差为
    A = sum(a) - sum(b)

    a的第i个元素和b的第j个元素交换后，a和b的和之差为
    A' = sum(a) - a[i] + b[j] - （sum(b) - b[j] + a[i])
           = sum(a) - sum(b) - 2 (a[i] - b[j])
           = A - 2 (a[i] - b[j])

    设x = a[i] - b[j]
    |A| - |A'| = |A| - |A-2x|

    假设A > 0,
    当x 在 (0,A)之间时，做这样的交换才能使得交换后的a和b的和之差变小，
x越接近A/2效果越好,
    如果找不到在(0,A)之间的x，则当前的a和b就是答案。

    所以算法大概如下：
    在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，
重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。

/////////////////////////////////////////
算法
1. 将两序列合并为一个序列，并排序，为序列Source 
2. 拿出最大元素Big，次大的元素Small 
3. 在余下的序列S[:-2]进行平分，得到序列max，min 
4. 将Small加到max序列，将Big加大min序列，重新计算新序列和，和大的为max，小的为min。
////////////////////////////////////////////////

def mean( sorted_list ):
    if not sorted_list:
        return (([],[]))
 
    big = sorted_list[-1]
    small = sorted_list[-2]
    big_list, small_list = mean(sorted_list[:-2])
 
    big_list.append(small)
    small_list.append(big)
 
    big_list_sum = sum(big_list)
    small_list_sum = sum(small_list)
 
    if big_list_sum > small_list_sum:
        return ( (big_list, small_list))
    else:
        return (( small_list, big_list))
 
tests = [   [1,2,3,4,5,6,700,800],
            [10001,10000,100,90,50,1],
            range(1, 11),
            [12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]
            ]
for l in tests:
    l.sort()
    print
    print "Source List:/t", l
    l1,l2 = mean(l)
    print "Result List:/t", l1, l2
    print "Distance:/t", abs(sum(l1)-sum(l2))
    print '-*'*40

输出结果
Source List:    [1, 2, 3, 4, 5, 6, 700, 800]
Result List:    [1, 4, 5, 800] [2, 3, 6, 700]
Distance:       99
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List:    [1, 50, 90, 100, 10000, 10001]
Result List:    [50, 90, 10000] [1, 100, 10001]
Distance:       38
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List:    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Result List:    [2, 3, 6, 7, 10] [1, 4, 5, 8, 9]
Distance:       1
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List:    [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]
Result List:    [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]
Distance:       21

这个解法是错误的，思想上看动态规划，每次分别用最大的元素与次大的元素平衡前面的差异，但是最后的循环不变式并不能保证得到最优值；

如：Source List:    [1, 2, 3, 4, 5, 6, 700, 800]
Result List:    [1, 4, 5, 800] [2, 3, 6, 700]
Distance:       99

就是错的应该是[1,2,3,800],[4,5,6,700]

我觉得可以加上一个后期修正，利用前面的推论    在a和b中寻找使得x在(0,A)之间并且最接近A/2的i和j，交换相应的i和j元素，
重新计算A后，重复前面的步骤直至找不到(0,A)之间的x为止。和已排序，在交换

还有一种思路就是：转化为：2n个数组，把它划分为两个数组并且使之和之差最小，编程之美有详细解答；