01背包+完全背包 HDU2602+HDU1114

好长一段时间没写东西了，人都懒下去了，尽管有做一些题 但都没有去整理，都懒得停下仔细思考，得过且过，模棱两可。废话不多，进入正题。
01背包可以说是最基础的背包模型，后面各种背包模型都是由01背包推导而来，因此一定要先掌握01背包。下面从题目hdu2602来解释01背包中的各处细节。
Bone Collector

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 45866 Accepted Submission(s): 19093

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

拿测试用例来说，有5件物品，价值分别为1，2，3，4，5 重量分别为5，4，3，2，1 在重量为10的背包中，放入多少件物品，使得背包的价值最大。动态规划的题一般来说不能用贪心解决，思想是将一个大问题划分为N个小问题，而这N个小问题都不是独立的（也就是我们所说的存在递推关系）。对于背包问题来说，该测试数据，5件物品，对每一件都进行分析，该件物品取还是不取，我们用一个二维数组来存物品，与重量的关系。
![dp表格](https://img-blog.csdn.net/20160324153143162)
for（int i=1;i<=n;i++)//n件物品
    for(int j=0;j<=w;j++)//背包重量
    {
    if(j>=weight[i])
    dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
    else 
    dp[i][j]=dp[i-1][j];
    }

#include <iostream> 
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
//int weight[1005];
//int value[1005];
struct GOODS{
    int weight;
    int value;
}goods[1005];
int dp[1005][1005];
int cmp(GOODS a,GOODS b)
{
    return a.weight<b.weight;
}
int main(int argc, char *argv[])
{
    int t;
    int n,v;
     cin>>t;
     while(t--)
    {
    memset(dp,0,sizeof(dp));    
    cin>>n>>v;
    for(int i=1;i<=n;i++)
    cin>>goods[i].value;
    for(int i=1;i<=n;i++)       
    cin>>goods[i].weight;
    sort(goods+1,goods+n+1,cmp);//排序并不能提高效率 
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=v;j++) 
        {if(goods[i].weight<=j)
        {
        dp[i][j]=max(dp[i-1][j],dp[i-1][j-goods[i].weight]+goods[i].value);
        }   
        else dp[i][j]=dp[i-1][j];

        }
    }

    cout<<dp[n][v]<<endl;
    }
    return 0;
}

HDU1114 完全背包
Piggy-Bank

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 18524 Accepted Submission(s): 9365

Problem Description

Before ACM can do anything, a budget must be prepared and the necessary financial support obtained. The main income for this action comes from Irreversibly Bound Money (IBM). The idea behind is simple. Whenever some ACM member has any small money, he takes all the coins and throws them into a piggy-bank. You know that this process is irreversible, the coins cannot be removed without breaking the pig. After a sufficiently long time, there should be enough cash in the piggy-bank to pay everything that needs to be paid.

But there is a big problem with piggy-banks. It is not possible to determine how much money is inside. So we might break the pig into pieces only to find out that there is not enough money. Clearly, we want to avoid this unpleasant situation. The only possibility is to weigh the piggy-bank and try to guess how many coins are inside. Assume that we are able to determine the weight of the pig exactly and that we know the weights of all coins of a given currency. Then there is some minimum amount of money in the piggy-bank that we can guarantee. Your task is to find out this worst case and determine the minimum amount of cash inside the piggy-bank. We need your help. No more prematurely broken pigs!

Input

The input consists of T test cases. The number of them (T) is given on the first line of the input file. Each test case begins with a line containing two integers E and F. They indicate the weight of an empty pig and of the pig filled with coins. Both weights are given in grams. No pig will weigh more than 10 kg, that means 1 <= E <= F <= 10000. On the second line of each test case, there is an integer number N (1 <= N <= 500) that gives the number of various coins used in the given currency. Following this are exactly N lines, each specifying one coin type. These lines contain two integers each, Pand W (1 <= P <= 50000, 1 <= W <=10000). P is the value of the coin in monetary units, W is it’s weight in grams.

Output

Print exactly one line of output for each test case. The line must contain the sentence “The minimum amount of money in the piggy-bank is X.” where X is the minimum amount of money that can be achieved using coins with the given total weight. If the weight cannot be reached exactly, print a line “This is impossible.”.

Sample Input

3
10 110
2
1 1
30 50
10 110
2
1 1
50 30
1 6
2
10 3
20 4

Sample Output

The minimum amount of money in the piggy-bank is 60.
The minimum amount of money in the piggy-bank is 100.
This is impossible.

//------------------完全背包--------------------------
#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
struct COIN{
    int value;  
    int weight;
}coin[505];
int dp[505][10005];
int main(int argc, char *argv[])
{
    int t;
    int n;
    int e,f;
    cin>>t;
    while(t--)
    {

    cin>>e>>f;
    cin>>n;

    for(int i=1;i<=n;i++)       
        {
        cin>>coin[i].value>>coin[i].weight;
        }
    int w=f-e;
    for(int i=0;i<=n;i++)
    for(int j=0;j<=w;j++)
    {
        if(j==0)    
        dp[i][0]=0;
        else 
        dp[i][j]=100000000;
    }
    for(int i=1;i<=n;i++)
        for(int j=0;j<=w;j++)
        {
            if(j>=coin[i].weight)
            {
                dp[i][j]=min(dp[i-1][j],dp[i][j-coin[i].weight]+coin[i].value);
            }
            else 
                dp[i][j]=dp[i-1][j];
        }
        if(dp[n][w]==100000000)
        cout<<"This is impossible."<<endl;
        else 
        cout<<"The minimum amount of money in the piggy-bank is "<<dp[n][w]<<"."<<endl;     

    }
    return 0;
} 

不要问我为什么不解释一下，我发现有些东西好难讲出来，可能是因为我还没有完全掌握吧，相对于前面深搜的部分，动态规划这部分我理解的还不够深，有些东西就是不知道怎么讲，SO超难受= =。。。。。ORZ. 烂尾了，弄懂一点希望能来补充吧