WHUgirls

Time Limit: 3000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 2050    Accepted Submission(s): 780

Problem Description There are many pretty girls in Wuhan University, and as we know, every girl loves pretty clothes, so do they. One day some of them got a huge rectangular cloth and they want to cut it into small rectangular pieces to make scarves. But different girls like different style, and they voted each style a price wrote down on a list. They have a machine which can cut one cloth into exactly two smaller rectangular pieces horizontally or vertically, and ask you to use this machine to cut the original huge cloth into pieces appeared in the list. Girls wish to get the highest profit from the small pieces after cutting, so you need to find out a best cutting strategy. You are free to make as many scarves of a given style as you wish, or none if desired. Of course, the girls do not require you to use all the cloth. Input The first line of input consists of an integer T, indicating the number of test cases.
The first line of each case consists of three integers N, X, Y, N indicating there are N kinds of rectangular that you can cut in and made to scarves; X, Y indicating the dimension of the original cloth. The next N lines, each line consists of two integers, xi, yi, ci, indicating the dimension and the price of the ith rectangular piece cloth you can cut in.
Output Output the maximum sum of prices that you can get on a single line for each case.

Constrains
0 < T <= 20
0 <= N <= 10; 0 < X, Y <= 1000
0 < xi <= X; 0 < yi <= Y; 0 <= ci <= 1000
Sample Input 1 2 4 4 2 2 2 3 3 9 Sample Output 9

//首先應該能想到這是個完全揹包的問題，但是要考慮到邊長。所以開個二維陣列,dp[i][j],代表前i長，前j寬的時候最大的價值是多少
//因為在進行分割的時候只能是橫這切或者豎著切，並且小的長方形既可以橫這擺，也可以豎著擺。所以有四種狀態。
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <string>
#include <math.h>
#include <limits.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <deque>
#include <vector>
#include <set>
#include <map>
using namespace std;
#define N 1000 + 10
#define M 10 + 2
struct node{
    int x;
    int y;
    int val;
}a[N];
int dp[N][N];

int max(int a,int b){
    return a>b?a:b;
}

int main(){
    int T,n;
    int X,Y;

    while(~scanf("%d",&T)){
        while(T--){
            memset(dp,0,sizeof(dp));
            memset(a,0,sizeof(a));
            scanf("%d%d%d",&n,&X,&Y);
            int i;
            for(i=0;i<n;i++){
                scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].val);
            }
            int j,k;
            for(i=1;i<=X;i++){
                for(j=1;j<=Y;j++){
                    for(k=0;k<n;k++){
                        if(i>=a[k].x && j>=a[k].y)
                            dp[i][j] = max(dp[i][j],max(dp[i-a[k].x][j]+dp[a[k].x][j-a[k].y],dp[i][j-a[k].y]+dp[i-a[k].x][a[k].y])+a[k].val);//因為i，j是從小到大的。所以每次取的時候都能去最優解。因為每次分割的時候都能變成三個小的矩形。所以要取最優
                        if(i>=a[k].y && j>=a[k].x)
                            dp[i][j] = max(dp[i][j],max(dp[i-a[k].y][j]+dp[a[k].y][j-a[k].x],dp[i][j-a[k].x]+dp[i-a[k].y][a[k].x])+a[k].val);
                    }
                }
            }
            printf("%d\n",dp[X][Y]);
        }
    }

    return 0;
}