http://blog.csdn.net/linyunzju/article/details/7729774

问题：

1. 有一个无序、元素个数为2n的正整数数组，要求：如何能把这个数组分割为两个子数组，子数组的元素个数不限，并使两个子数组之和最接近。

2. 有一个无序、元素个数为2n的正整数数组，要求：如何能把这个数组分割为元素个数为n的两个数组，并使两个子数组之和最接近。

1. 解法1：

由于对两个子数组和最接近的判断不太直观，我们需要对题目进行适当转化。我们知道当一个子数组之和最接近原数组之和sum的一半时，两个子数组之和是最接近的。所以转化后的题目是：从2n个数中选出任意个数，其和尽量接近于给定值sum/2。

这个问题存储的是从前k个数中选取任意个数，且其和为s的取法是否存在dp[k][s]。之所以将选出的数之和放在下标中，而不是作为dp[k]的值，是因为那种做法不满足动态规划的前提——最优化原理，假设我们找到最优解有k个数p1p2…pk（选出的这k个数之和是最接近sum/2的），但最优解的前k-1个数p1p2…pk-1之和可能并不是最接近sum/2的，也就是说可能在访问到pk之前有另一组数q1q2….qk-1其和相比p1p2…pk-1之和会更接近sum/2，即最优解的子问题并不是最优的，所以不满足最优化原理。因此我们需要将dp[k]的值作为下标存储起来，将这个最优问题转化为判定问题，用带动态规划的思想的递推法来解。

外阶段：在前k1个数中进行选择，k1=1,2…2*n。
内阶段：从这k1个数中任意选出k2个数，k2=1,2…k1。

状态：这k2个数的和为s，s=1,2…sum/2。

决策：决定这k2个数的和有两种决策，一个是这k2个数中包含第k1个数，另一个是不包含第k1个数。
dp[k][s]表示从前k个数中取任意个数，且这些数之和为s的取法是否存在。

[cpp] 
view plain
copy

1. #include <iostream>  
2. #include <algorithm>  
3.   
4. using namespace std;  
5.   
6. #define MAXN 101  
7. #define MAXSUM 100000  
8. int A[MAXN];  
9. bool dp[MAXN][MAXSUM];  
10.   
11. // dp[k][s]表示从前k个数中去任意个数，且这些数之和为s的取法是否存在  
12. int main()  
13. {  
14.     int n, i, k1, k2, s, u;  
15.     cin >> n;  
16.     for (i=1; i<=2*n; i++)  
17.         cin >> A[i];  
18.     int sum = 0;  
19.     for (i=1; i<=2*n; i++)  
20.         sum += A[i];  
21.     memset(dp,0,sizeof(dp));  
22.     dp[0][0]=true;  
23.     // 外阶段k1表示第k1个数，内阶段k2表示选取数的个数  
24.     for (k1=1; k1<=2*n; k1++)            // 外阶段k1  
25.     {  
26.         for (k2=k1; k2>=1; k2–)     // 内阶段k2  
27.             for (s=1; s<=sum/2; s++) // 状态s  
28.             {  
29.                 //dp[k1][s] = dp[k1-1][s];  
30.                 // 有两个决策包含或不包含元素k1  
31.                 if (s>=A[k1] && dp[k2-1][s-A[k1]])  
32.                     dp[k2][s] = true;  
33.             }  
34.     }  
35.     // 之前的dp[k][s]表示从前k个数中取任意k个数，经过下面的步骤后  
36.     // 即表示从前k个数中取任意个数  
37.     for (k1=2; k1<=2*n; k1++)  
38.         for (s=1; s<=sum/2; s++)  
39.             if (dp[k1-1][s]) dp[k1][s]=true;  
40.     // 确定最接近的给定值sum/2的和  
41.     for (s=sum/2; s>=1 && !dp[2*n][s]; s–);  
42.     printf(“the differece between two sub array is %d\n”, sum-2*s);  
43. }  

解法2：

由于题目不限制子数组的元素个数，限制条件少，可以进行优化。实际上解法1的思路主要是为了题目2做铺垫，使得题目2的解法不至于太难理解。该题实际上有更简单的解法，该解法的思路和0-1背包问题的思路是一样的。

[cpp] 
view plain
copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. #define MAXN 101  
5. #define MAXSUM 100000  
6. int A[MAXN];  
7. bool dp[MAXN][MAXSUM];  
8.   
9. // dp[k][s]表示从前k个数中取任意个数，且这些数之和为s的取法是否存在  
10. int main()  
11. {  
12.     int k, s, u, i, n;  
13.     cin >> n;  
14.     for (i=1; i<=2*n; ++i)  
15.         cin >> A[i];  
16.     int sum = 0;  
17.     for (i=1; i<=2*n; ++i)  
18.         sum += A[i];  
19.     dp[0][0] = true;  
20.     // 阶段k表示第k个数  
21.     for (k=1; k<=2*n; ++k)  
22.         // 注意状态可取0  
23.         for (s=0; s<=(sum>>1); ++s)  
24.         {  
25.             // 加上第k个数,或不加它所能得到的和  
26.             if (s>=A[k])  
27.                 dp[k][s] = dp[k-1][s-A[k]] || dp[k-1][s];  
28.             else  
29.                 dp[k][s] = dp[k-1][s];  
30.         }  
31.     for (s=(sum>>1); s>=1 && !dp[2*n][s]; –s);  
32.     cout << sum-2*s;  
33. }  
34.    

2. 解法：

但本题还增加了一个限制条件，即选出的物体数必须为n，这个条件限制了内阶段k2的取值范围，并且dp[k][s]的含义也发生变化。这里的dp[k][s]表示从前k个数中取k个数，且k不超过n，且这些数之和为s的取法是否存在。

[cpp] 
view plain
copy

1. #include <iostream>  
2. #include <algorithm>  
3.   
4. using namespace std;  
5.   
6. #define MAXN 101  
7. #define MAXSUM 100000  
8. int A[MAXN];  
9. bool dp[MAXN][MAXSUM];  
10.   
11. // 题目可转换为从2n个数中选出n个数，其和尽量接近于给定值sum/2  
12. int main()  
13. {  
14.     int n, i, k1, k2, s, u;  
15.     cin >> n;  
16.     for (i=1; i<=2*n; i++)  
17.         cin >> A[i];  
18.     int sum = 0;  
19.     for (i=1; i<=2*n; i++)  
20.         sum += A[i];  
21.     memset(dp,0,sizeof(dp));  
22.     dp[0][0]=true;  
23.     // 对于dp[k][s]要进行u次决策，由于阶段k的选择受到决策的限制，  
24.     // 这里决策选择不允许重复，但阶段可以重复，比较特别  
25.     for (k1=1; k1<=2*n; k1++)                // 外阶段k1  
26.         for (k2=min(k1,n); k2>=1; k2–)      // 内阶段k2  
27.             for (s=1; s<=sum/2; s++) // 状态s  
28.                 // 有两个决策包含或不包含元素k1  
29.                 if (s>=A[k1] && dp[k2-1][s-A[k1]])  
30.                     dp[k2][s] = true;  
31.     // 确定最接近的给定值sum/2的和  
32.     for (s=sum/2; s>=1 && !dp[n][s]; s–);  
33.     printf(“the differece between two sub array is %d\n”, sum-2*s);