HDU_最大报销额(DP)

最大报销额

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 17519    Accepted Submission(s): 5137

Problem Description

现有一笔经费可以报销一定额度的发票。允许报销的发票类型包括买图书（A类）、文具（B类）、差旅（C类），要求每张发票的总额不得超过1000元，每张发票上，单项物品的价值不得超过600元。现请你编写程序，在给出的一堆发票中找出可以报销的、不超过给定额度的最大报销额。

 

Input

测试输入包含若干测试用例。每个测试用例的第1行包含两个正数 Q 和 N，其中 Q 是给定的报销额度，N（<=30）是发票张数。随后是 N 行输入，每行的格式为：
m Type_1:price_1 Type_2:price_2 ... Type_m:price_m
其中正整数 m 是这张发票上所开物品的件数，Type_i 和 price_i 是第 i 项物品的种类和价值。物品种类用一个大写英文字母表示。当N为0时，全部输入结束，相应的结果不要输出。

 

Output

对每个测试用例输出1行，即可以报销的最大数额，精确到小数点后2位。

 

Sample Input

  
  

   
   200.00 3
2 A:23.50 B:100.00
1 C:650.00
3 A:59.99 A:120.00 X:10.00
1200.00 2
2 B:600.00 A:400.00
1 C:200.50
1200.50 3
2 B:600.00 A:400.00
1 C:200.50
1 A:100.00
100.00 0
  
  

 

Sample Output

  
  

   
   123.50
1000.00
1200.50
  
  

 

题解：题目的输入比较麻烦。在判断是否为合法发票的前提下，很容易能看出这道题属于01背包。

因为报销额为double型，所以我们对每张发票是否放入进行dp。递推公式为：dp[i]=max(dp[i],dp[i-1]+sum),sum=Ai+Bi+Ci;

或者所有参数*100，转换成最基本的01背包，但是时间复杂度会高一些。

思考：

最开始的时候是看别人的代码，才写出了dp函数的循环递推，但是根本没有理解。后来在做到类似的题目才反过来看，却又看不懂了，debug了很久才发现自己最开始的理解就是错的。这个方法其实是很有贪心的意思，我们先从定义开始慢慢理解。

dp[i]:报销i张发票得到的最大报销额。（注意是报销i张，而没有强调是第i张或前i张，有从N张中挑i张得到最大值的意思）

外层循环：从0~n-1将n张发票代入，以此尝试更新dp数组。

内层循环:这里是最迷惑人的，因为普通的01内层确实是倒序，为了保证某件物品只可能被放入一次。但是关键那样内层循环应从MAX~0，MAX表示发票总额能达到的最大值，而这道题因为是double类型，这是无法实现的(不扩大100倍的话)。在下面代码中我们从N~1倒序遍历，在避免了多次放入的同时，dp数组从N到1逐个尝试更新，每次都保证我们存储的是当报销1,2...j...N张时的最大值。依据贪心思想得到最终报销N张能得到的最大值。递推式dp[i]=max(dp[i],dp[j]+sum[i](1<=j<=N));经过认真地思考得到的知识更让我感到珍惜。。

附代码：

<pre name="code" class="cpp">#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <limits.h>
#include <algorithm>
#include <map>
#define MAX_N 40
using namespace std;

double l[MAX_N][5];
int show[MAX_N];//是否合法map<T&extra,bool>或许也是一个不错的选择
double dp[MAX_N];//储存从前i张发票中选取能报销的最大值
map<char,int> ml;//绑定ABC与012
int main()
{
    double Q;
    int N,m;
    double result;
    bool flag;
    while( scanf("%lf%d",&Q,&N) != EOF && N )
    {
        memset(l,0,sizeof(l));
        memset(show,0,sizeof(show));
        memset(dp,0,sizeof(dp));
        ml['A']=0;
        ml['B']=1;
        ml['C']=2;
        for( int i = 0; i < N; i++ )
        {
            scanf("%d",&m);
            flag=true;
            for( int j = 0; j < m; j++ )
            {
                char c;double x;
                scanf(" %c:%lf",&c,&x);//输入
                if( (c!='A'&&c!='B'&&c!='C') || x > 600)
                {
                    flag=false;
                    continue;
                }
                l[i][ml[c]]+=x;
            }
            //这里要注意可能有多个A或其他类型出现，所以要总体再判断一次
            if( flag && l[i][0]+l[i][1]+l[i][2] <= 1000 && l[i][0]<=600 && l[i][1]<=600 && l[i][2]<=600 )
                show[i]=1;
        }
        result=0;
        for( int i = 0; i < N; i++ )
        {
            double sum=0;
            if( show[i] == 1 )
                sum=l[i][0]+l[i][1]+l[i][2];
            //倒序更新
            for( int j = N; j >= 1; j-- )
            {<span style="font-family: Arial, Helvetica, sans-serif;">        </span>

<span style="font-family: Arial, Helvetica, sans-serif;"> <span style="white-space:pre">				</span>if( j == 1 || (dp[j-1]>0&&dp[j-1]+sum<=Q) )</span>

                    dp[j]=max(dp[j],dp[j-1]+sum);
                result=max(result,dp[j]);
            }
        }
        printf("%.2lf\n",result);
    }
    return 0;
}

因为N<=30，所以或许dfs也是一种不错的选择。

附上同学dfs的代码：

<pre name="code" class="cpp">#include <cstdio>
#include <vector>
#include <string.h>
#include <algorithm>
#include <hash_map>
using namespace std;
double total, one, kind[3], ans;
int N, item, vlen;
char type;
bool useless;
std::vector<double> v;
std::hash_map <double, bool> vis;

void dfs(int k, double sum) {
    //此处剪枝
    if(ans == total || vis[sum]) return ;
    vis[sum] = true;
    if(sum > ans) {
        ans = sum;
    }
    for (int i = k; i < vlen; i ++){
        if(sum + v[i] <= total){
            dfs(i+1, sum + v[i]);
        } else break;
    }
}
int main() {
    while(scanf("%lf%d", &total, &N) != EOF, N) {
        v.clear();
        for (int i = 0; i < N; i ++) {
            scanf("%d", &item);
            useless = false;
            kind[0]  = kind[1] = kind[2]= 0;
            while(item --) {
                scanf(" %c:%lf", &type, &one);
                if(useless == true) continue;
                if(type > 'C' || kind[type- 'A'] + one  > 600) {
                    useless = true;
                }
                kind[type-'A'] += one;
                if(kind[0] + kind[1] + kind[2] > 1000) {
                    useless = true;
                }
            }
            if(useless == false) {
                v.push_back(kind[0] + kind[1] + kind[2]);
            }
        }
        vlen = v.size(), ans = 0;
        vis.clear();
        //这里有一个排序操作，考虑到时间复杂度，较小的sum会更容易被
        //用到,换句话说就是能更大程度的剪枝
        std::sort(v.begin(), v.end());
        dfs(0, 0);
        printf("%.2lf\n", ans);
    }
    return 0;
}

附代码：