数组分割

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

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3.   
4. //有一个没有排序，元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组，并使两个子数组的和最接近。  
5. int arr[] = {0,1,5,7,8,9,6,3,11,20,17};  
6. const int N=5;  
7. const int SUM = 87;  
8.   
9. // 模仿动态规划解0-1背包问题的策略  
10. int solve1()  
11. {  
12.     int i , j , s;  
13.     int dp[2*N+1][N+1][SUM/2+2];  
14.   
15.     /* 
16.     用dp(i,j,c)来表示从前i个元素中取j个、且这j个元素之和不超过c的最佳(大)方案，在这里i>=j,c<=S 
17.     状态转移方程：    
18.     限第i个物品　　　　　　　不取　　 
19.     dp(i,j,c)=max{dp(i-1,j-1,c-a[i])+a[i]，dp(i-1,j,c)} 
20.     dp(2N,N,SUM/2+1)就是题目的解。 
21.     */  
22.     //初始化  
23.     memset(dp,0,sizeof(dp));  
24.   
25.     for(i = 1 ; i <= 2*N ; ++i)  
26.     {  
27.         for(j = 1 ; j <= min(i,N) ; ++j)  
28.         {  
29.             for(s = SUM/2+1 ; s >= arr[i] ; --s)  
30.             {  
31.                 dp[i][j][s] = max(dp[i-1][j-1][s-arr[i]]+arr[i] , dp[i-1][j][s]);  
32.             }  
33.         }  
34.     }  
35.   
36.     //因为这为最终答案　dp[2*N][N][SUM/2+1];  
37.     i=2*N , j=N , s=SUM/2+1;  
38.     while(i > 0)  
39.     {  
40.         if(dp[i][j][s] == dp[i-1][j-1][s-arr[i]]+arr[i])   //判定这个状态是由哪个状态推导出来的  
41.         {  
42.             cout<<arr[i]<<" ";    //取中arr[i]  
43.             j--;  
44.             s -= arr[i];  
45.         }     
46.         i--;  
47.     }  
48.     cout<<endl;  
49.     return dp[2*N][N][SUM/2+1];  
50. }  
51.   
52. int solve2()  
53. {  
54.     int i , j , s;  
55.     int dp[N+1][SUM/2+2];     //取Ｎ+１件物品，总合不超过SUM/2+2，的最大值是多少   
56.     memset(dp,0,sizeof(dp));    //初始状态都为0  
57.   
58.     for(i = 1 ; i <= 2*N ; ++i)  
59.     {  
60.         for(j = 1 ; j <= min(i,N) ; ++j)  
61.         {  
62.             for(s = SUM/2+1 ; s >= arr[i] ; --s)    //01背包从大到小，可以省空间，即最外层的空间  
63.             {  
64.                 dp[j][s] = max(dp[j-1][s-arr[i]]+arr[i] , dp[j][s]);   
65.             }  
66.         }  
67.     }  
68.     //要求最优解则　空间不能优化，  
69.     return dp[N][SUM/2+1];  
70. }  
71.   
72. int solve3()  
73. {  
74.     int i , j , s;  
75.     int isOK[N+1][SUM/2+2]; //isOK[i][v]表示是否可以找到i个数，使得它们之和等于v  
76.     memset(isOK,0,sizeof(isOK));    //都不合法  
77.     //注意初始化  
78.     isOK[0][0] = 1; //可以,取0件物品，总合为0，是合法的  
79.   
80.     for(i = 1 ; i <= 2*N ; ++i)  
81.     {  
82.         for( j = 1 ; j <= min(i,N) ; ++j)  
83.         {  
84.             for(s = SUM/2+1 ; s >= arr[i] ; --s) //从大到小，数组少了一维  
85.             {  
86.                 if( isOK[j-1][s-arr[i]] )  
87.                     isOK[j][s] = 1;  
88.             }  
89.         }  
90.     }  
91.     for(s = SUM/2+1 ; s >= 0 ; --s)  
92.     {  
93.         if(isOK[N][s])  
94.             return s;  
95.     }  
96.   
97.     //要求最优解则空间不能优化  
98.     return 0;  
99. }  
100.   
101. int main(void)  
102. {  
103.     int s1 = solve1();  
104.     int s2 = solve2();  
105.     int s3 = solve3();  
106.     cout<<"s1="<<s1<<endl;  
107.     cout<<"s2="<<s2<<endl;  
108.     cout<<"s3="<<s3<<endl;  
109.     system("pause");  
110.     return 0;  
111. }  

二、扩展问题：  交换两个数组元素使两个数组和的差最小
有两个数组a、b，大小都为n,数组元素的值任意整形数，无序；
要求：通过交换a、b数组中的元素，使[数组a元素的和]与[数组b元素的和]之间的差最小。
其实这个问题就是上面问题的变形，将a、b两个数组合并为一个数组，然后问题就转化为将2*n个元素数组分割为2个长度为n的数组，并使两个子数组的和最接近。
另外，特别注意：如果数组中有负数的话，上面的背包策略就不能使用了（因为第三重循环中的s是作为数组的下标的，不能出现负数的），需要将数组中的所有数组都加上最小的那个负数的绝对值，将数组中的元素全部都增加一定的范围，全部转化为正数，然后再使用上面的背包策略就可以解决了。