程序员面试100题之十三:数组分割

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

//有一个没有排序,元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组,并使两个子数组的和最接近。
int arr[] = {0,1,5,7,8,9,6,3,11,20,17};
const int N=5;
const int SUM = 87;

// 模仿动态规划解0-1背包问题的策略
int solve1()
{
	int i , j , s;
	int dp[2*N+1][N+1][SUM/2+2];

	/*
	用dp(i,j,c)来表示从前i个元素中取j个、且这j个元素之和不超过c的最佳(大)方案,在这里i>=j,c<=S
	状态转移方程:   
	限第i个物品       不取  
	dp(i,j,c)=max{dp(i-1,j-1,c-a[i])+a[i],dp(i-1,j,c)}
	dp(2N,N,SUM/2+1)就是题目的解。
	*/
	//初始化
	memset(dp,0,sizeof(dp));

	for(i = 1 ; i <= 2*N ; ++i)
	{
		for(j = 1 ; j <= min(i,N) ; ++j)
		{
			for(s = SUM/2+1 ; s >= arr[i] ; --s)
			{
				dp[i][j][s] = max(dp[i-1][j-1][s-arr[i]]+arr[i] , dp[i-1][j][s]);
			}
		}
	}

	//因为这为最终答案 dp[2*N][N][SUM/2+1];
	i=2*N , j=N , s=SUM/2+1;
	while(i > 0)
	{
		if(dp[i][j][s] == dp[i-1][j-1][s-arr[i]]+arr[i])   //判定这个状态是由哪个状态推导出来的
		{
			cout<<arr[i]<<" ";    //取中arr[i]
			j--;
			s -= arr[i];
		}	
		i--;
	}
	cout<<endl;
	return dp[2*N][N][SUM/2+1];
}

int solve2()
{
	int i , j , s;
	int dp[N+1][SUM/2+2];     //取N+1件物品,总合不超过SUM/2+2,的最大值是多少 
	memset(dp,0,sizeof(dp));    //初始状态都为0

	for(i = 1 ; i <= 2*N ; ++i)
	{
		for(j = 1 ; j <= min(i,N) ; ++j)
		{
			for(s = SUM/2+1 ; s >= arr[i] ; --s)    //01背包从大到小,可以省空间,即最外层的空间
			{
				dp[j][s] = max(dp[j-1][s-arr[i]]+arr[i] , dp[j][s]); 
			}
		}
	}
	//要求最优解则 空间不能优化,
	return dp[N][SUM/2+1];
}

int solve3()
{
	int i , j , s;
	int isOK[N+1][SUM/2+2]; //isOK[i][v]表示是否可以找到i个数,使得它们之和等于v
	memset(isOK,0,sizeof(isOK));    //都不合法
	//注意初始化
	isOK[0][0] = 1; //可以,取0件物品,总合为0,是合法的

	for(i = 1 ; i <= 2*N ; ++i)
	{
		for( j = 1 ; j <= min(i,N) ; ++j)
		{
			for(s = SUM/2+1 ; s >= arr[i] ; --s) //从大到小,数组少了一维
			{
				if( isOK[j-1][s-arr[i]] )
					isOK[j][s] = 1;
			}
		}
	}
	for(s = SUM/2+1 ; s >= 0 ; --s)
	{
		if(isOK[N][s])
			return s;
	}

	//要求最优解则空间不能优化
	return 0;
}

int main(void)
{
	int s1 = solve1();
	int s2 = solve2();
	int s3 = solve3();
	cout<<"s1="<<s1<<endl;
	cout<<"s2="<<s2<<endl;
	cout<<"s3="<<s3<<endl;
	system("pause");
	return 0;
}
二、 扩展问题:  交换两个数组元素使两个数组和的差最小
有两个数组a、b,大小都为n,数组元素的值任意整形数,无序;
要求:通过交换a、b数组中的元素,使[数组a元素的和]与[数组b元素的和]之间的差最小。

其实这个问题就是上面问题的变形,将a、b两个数组合并为一个数组,然后问题就转化为将2*n个元素数组分割为2个长度为n的数组,并使两个子数组的和最接近。
另外,特别注意:如果数组中有负数的话,上面的背包策略就不能使用了(因为第三重循环中的s是作为数组的下标的,不能出现负数的),需要将数组中的所有数组都加上最小的那个负数的绝对值,将数组中的元素全部都增加一定的范围,全部转化为正数,然后再使用上面的背包策略就可以解决了。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值