搭建双塔

【问题描述】

　　2001年9月11日，一场突发的灾难将纽约世界贸易中心大厦夷为平地，Mr. F曾亲眼目睹了这次灾难。为了纪念“9?11”事件，Mr. F决定自己用水晶来搭建一座双塔。

　　Mr. F有N块水晶，每块水晶有一个高度，他想用这N块水晶搭建两座有同样高度的塔，使他们成为一座双塔，Mr. F可以从这N块水晶中任取M（1≤M≤N）块来搭建。但是他不知道能否使两座塔有同样的高度，也不知道如果能搭建成一座双塔，这座双塔的最大高度是多少。所以他来请你帮忙。

　　给定水晶的数量N和每块水晶的高度Hi，你的任务是判断Mr. F能否用这些水晶搭建成一座双塔（两座塔有同样的高度），如果能，则输出所能搭建的双塔的最大高度，否则输出“Impossible”。

【输入格式】

　　第一行为一个数N，表示水晶的数量。
　　第二行为N个数，第i个数表示第i个水晶的高度。

【输出格式】

　　输出仅包含一行，如果能搭成一座双塔，则输出双塔的最大高度，否则输出一个字符串“Impossible”。

【输入样例】

5
1 3 4 5 2

【输出样例】

7

【数据范围】

50%的数据：1≤N≤20， N块水晶高度的总和不超过2000；
70%的数据：1≤N≤100， N块水晶高度的总和不超过2000；
100%的数据：1≤N≤100， N块水晶高度的总和不超过500000。
解题思路（正解）：因为已知如果直接求什么设什么是不行的，所以要换个思路来设计状态函数，因为求的双塔高度相同，即高度差为0，所以可以运用动态规划，设f(i,j)表示前i块水晶，选择一些搭出第一座塔与第二座塔的高度差为j时，第一座塔的最大高度，这样设的话，数组只需设f[105][500005]，不会超内存，但可以发现高度差j可能为负数，对此，可以运用宏定义将负数j平移为正数。同样，分析第i块水晶，可以不搭，可以搭在第一座塔上，也可以搭在第二座塔上，所以状态转移方程为f(i,j)=max(f(i-1,j),f(i-1,j-h[i]),f(i-1,j+h[i])+h[i])。边界条件为f(0,0)=0，即不选水晶，两座塔的高度差为0，求塔高也都为0。需要注意的是，因为此种设法分析前i块水晶时，仍只与前i-1块水晶有关，所以也可以使用滚动数组来优化空间，但又为了保证正确，可以用二维滚动数组，在枚举高度差j时，可以进行优化，先在输入时计算出前i块水晶的高度和sum[i]（前缀和），则枚举第i块水晶时，高度差最多为sum[i]，最少为-sum[i]。如果最后f(N%2,0)是小于或等于0的，说明不存在双塔，需输出“Impossible”。

#include<cstdio>  
#include<cstdlib>  
#include<iostream>  
#include<algorithm>  
#include<cstring>  
#define f(x,y) d[(x)][(y)+1000000]  //宏定义，注意建议平移多一点，不然可能有的数据会出问题  
using namespace std;  
const int maxn=105;  
const int inf=1000000010;  
int N,sum=0;  
int h[maxn],s[maxn];  
/* 
f(i,j)表示前i块水晶，选择一些搭出第一座塔与第二座塔的高度差为j时，第一座塔的最大高度  
f(i,j)=max(f(i-1,j),f(i-1,j-h[i]),f(i-1,j+h[i])+h[i]) 
边界：f(0,0)=0  
*/  
int d[2][2000005];  //二维滚动数组  
void solve()  //动态规划  
{  
    for(int i=0;i<2;i++)  
    for(int j=-sum;j<=sum;j++)  
    f(i,j)=-inf;  //初始化  
    f(0,0)=0;  //边界  
    for(int i=1;i<=N;i++)  
    {  
        for(int j=-s[i];j<=s[i];j++)  
        f(i%2,j)=-inf;  
        for(int j=-s[i];j<=s[i];j++)  
        {  
            int t1=f((i-1)%2,j),t2=f((i-1)%2,j-h[i]),t3=f((i-1)%2,j+h[i])+h[i];  
            f(i%2,j)=max(t1,max(t2,t3));  
        }  
    }  
    if(f(N%2,0)>0)  printf("%d\n",f(N%2,0));  
    else  printf("Impossible\n");  

}  
int main()  
{   
    scanf("%d",&N);  
    s[0]=0;  
    for(int i=1;i<=N;i++)  
    {  
        scanf("%d",&h[i]);  
        s[i]=s[i-1]+h[i];  //预处理，计算前缀和  
        sum+=h[i];  //计算高度差的范围  
    }  
    solve();  
    return 0;  
}  

第二种，麻烦点想，但好处是省空间
一看就跟背包有些类似，实际上确实是个很简单的DP

用dp[i][j] 表示的是前i个水晶，凑成的两塔高度差为j的较低塔的最大高度。

那么它的状态可能由四种情况转化而来

1.该物品没用上

2.低塔加上了该物品还是低塔

3.高塔加上了该物品边的更高了

4.低塔加上了该物品变成了高塔

这里我们可以画几个图，就清晰许多了

转移方程请看代码

#include <cstdio>  
#include <cstring>  
#include <algorithm>  
#include <vector>  
#include <queue>  
#include <set>  
#include <stack>  
#include <map>  
#define MAXN 777  
#define MAXM 400005  
#define INF 1000000007  
using namespace std; 
int n; 
int f[111][2222], c[111]; 
int main() 
{ 
    scanf("%d", &n); 
    int sum = 0; 
    for(int i = 1; i <= n; i++) 
    { 
        scanf("%d", &c[i]); 
        sum += c[i]; 
    } 
    memset(f, -1, sizeof(f)); 
    f[0][0] = 0; 
    for(int i = 1; i <= n; i++) 
    { 
        for(int j = 0; j <= sum; j++) 
        { 
            if(f[i - 1][j] != -1) f[i][j] = f[i - 1][j]; 
            if(j + c[i] <= sum && f[i - 1][j + c[i]] != -1) 
                f[i][j] = max(f[i][j], f[i - 1][j + c[i]] + c[i]); 
            if(j >= c[i] && f[i - 1][j - c[i]] != -1) 
                f[i][j] = max(f[i][j], f[i - 1][j - c[i]]); 
            if(c[i] > j && f[i - 1][c[i] - j] != -1) 
                f[i][j] = max(f[i][j], f[i - 1][c[i] - j] + c[i] - j); 
        } 
    } 
    if(f[n][0] > 0) printf("%d\n", f[n][0]); 
    else printf("Impossible\n"); 
    return 0; 
}