HDU 2602

/*

Bone Collector
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 42006 Accepted Submission(s): 17477

Problem Description
Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. This man like to collect
varies of bones , such as dog’s , cow’s , also he went to the grave …
The bone collector had a big bag with a volume of V ,and along his trip of collecting there are a lot of bones ,
obviously , different bone has different value and different volume, now given the each bone’s value along his
trip , can you calculate out the maximum of the total value the bone collector can get ?

Input
The first line contain a integer T , the number of cases.
Followed by T cases , each case three lines , the first line contain two integer N ,
V, (N <= 1000 , V <= 1000 )representing the number of bones and the volume of his bag. And the second line
contain N integers representing the value of each bone. The third line contain N integers representing the
volume of each bone.

Output
One integer per line representing the maximum of the total value (this number will be less than 231).

Sample Input

1
5 10
1 2 3 4 5
5 4 3 2 1

Sample Output

14

*/

1.记忆化搜索
思想：
01背包，每个种类的物品的数目只有一个，要么放进背包里，要么不放（01性的体现），但要求在当前背包容量下所能存储的值
相当于建立一棵满二叉树，然后遍历该二叉树求其最大值，因为会有重复的节点，开一个数组进行节点的记录，然后进行记忆化
搜索。这样就可以降低问题的复杂度，从而提升可解决问题的规模
Accepted 2602 374MS 5664K 946 B

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int SIZE = 1010;
int dp[SIZE][SIZE],value[SIZE],volume[SIZE];
int N,M;

int Solve(int i,int w){
    if(i==N) return 0;
    int ret;
    if(dp[i][w]>=0) return dp[i][w];
    if(volume[i]>w){
        ret = Solve(i+1,w);
    }
    else if(volume[i]<=w){
        ret = max(Solve(i+1,w),Solve(i+1,w-volume[i])+value[i]);
    }
    dp[i][w] = ret;
    return ret;
}

inline void Print(){
    cout << "DP:" << endl;
    for(int i=0;i<=N;i++){
        for(int j=0;j<=N;j++){
            printf("%4d",dp[i][j]);
        }
        putchar('\n');
    }
    return ;
}

int main(){
    int T;
    while(scanf("%d",&T)!=EOF){
        while(T--){
            memset(dp,-1,sizeof(dp));
            scanf("%d %d",&N,&M);
            for(int i=0;i<N;i++) scanf("%d",value+i);
            for(int i=0;i<N;i++) scanf("%d",volume+i);
            int res = Solve(0,M);
            cout << res << endl;
            //Print();
        }
    }
    return 0;
}

2.dp，建表
由记忆化搜索推导出递推式，进行dp求解。
根据dp[i][j]数组的含义及solve函数的运行原理：dp[i][j]表示从第i个物品开始挑选总重小于j时总价值的最
大值，可以得到其状态转移方程，从而可以不用递归直接用循环解决，进一步降低了时间复杂度。
状态转移方程为：
dp[n][j] = 0;
填表顺序是自底向上，从左至右
Accepted 2602 46MS 5480K 932 B G++

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int SIZE = 1010;
int dp[SIZE][SIZE],value[SIZE],volume[SIZE];
int N,M;

inline void Print(){
    cout << "DP:" << endl;
    for(int i=0;i<=N+1;i++){
        for(int j=0;j<=N+1;j++){
            printf("%4d",dp[i][j]);
        }
        putchar('\n');
    }
    return ;
}
//dp[i][j]表示从第i个物品开始挑选总重小于j时总价值的最大值
void Fill(){
    for(int j=0;j<=M;j++) dp[N][j] = 0;
    for(int i=N-1;i>=0;i--){
        for(int j=0;j<=M;j++){
            if(volume[i]>j) dp[i][j] = dp[i+1][j];
            else dp[i][j] = max(dp[i+1][j],dp[i+1][j-volume[i]]+value[i]);
        }
    }
    return ;
}

int main(){
    int T;
    while(scanf("%d",&T)!=EOF){
        while(T--){
            scanf("%d %d",&N,&M);
            for(int i=0;i<N;i++) scanf("%d",value+i);
            for(int i=0;i<N;i++) scanf("%d",volume+i);
            Fill();
            cout << dp[0][M] << endl;
        }
    }
    return 0;
}