HDU2639_Bone Collector II 01背包求第K优解

Bone Collector II

Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4306    Accepted Submission(s): 2239

Problem Description

The title of this problem is familiar,isn't it?yeah,if you had took part in the "Rookie Cup" competition,you must have seem this title.If you haven't seen it before,it doesn't matter,I will give you a link:

Here is the link: http://acm.hdu.edu.cn/showproblem.php?pid=2602

Today we are not desiring the maximum value of bones,but the K-th maximum value of the bones.NOTICE that,we considerate two ways that get the same value of bones are the same.That means,it will be a strictly decreasing sequence from the 1st maximum , 2nd maximum .. to the K-th maximum.

If the total number of different values is less than K,just ouput 0.

 

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, K(N <= 100 , V <= 1000 , K <= 30)representing the number of bones and the volume of his bag and the K we need. 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 K-th maximum of the total value (this number will be less than 2 ³¹).

 

Sample Input

  
  

   
   3
5 10 2
1 2 3 4 5
5 4 3 2 1
5 10 12
1 2 3 4 5
5 4 3 2 1
5 10 16
1 2 3 4 5
5 4 3 2 1
  
  

 

Sample Output

  
  

   
   12
2
0
  
  

 

求次优解、第 K 优解 对于求次优解、第 K 优解类的问题,如果相应的最优解问题能写出状态
转移方程、用动态规划解决,那么求次优解往往可以相同的复杂度解决,第 K 优解则比求最优解
的复杂度上多一个系数 K 。
其基本思想是将每个状态都表示成有序队列,将状态转移方程中的 max/min 转化成有序队
列的合并。这里仍然以 01 背包为例讲解一下。
首先看 01 背包求最优解的状态转移方程: f [i][v] = max{f [i − 1][v], f [i − 1][v − c[i]] + w[i]} 。如
果要求第 K 优解,那么状态 f[i][v] 就应该是一个大小为 K 的数组 f[i][v][1..K] 。其中 f[i][v][k] 表示前 i 个
物品、背包大小为 v 时,第 k 优解的值。“ f[i][v] 是一个大小为 K 的数组”这一句,熟悉 C 语言的同学
可能比较好理解,或者也可以简单地理解为在原来的方程中加了一维。显然 f[i][v][1..K] 这 K 个数
是由大到小排列的,所以我们把它认为是一个有序队列。
然后原方程就可以解释为: f[i][v] 这个有序队列是由 f[i-1][v] 和 f[i-1][v-c[i]]+w[i] 这两个有序队列
合并得到的。有序队列 f[i-1][v] 即 f[i-1][v][1..K] , f[i-1][v-c[i]]+w[i] 则理解为在 f[i-1][v-c[i]][1..K] 的每个数
上加上 w[i] 后得到的有序队列。合并这两个有序队列并将结果的前 K 项储存到 f[i][v][1..K] 中的复杂
度是 O(K) 。最后的答案是 f[N][V][K] 。总的复杂度是 Θ(V N K) 。

摘自背包九讲。

一开始我以为能够直接用set实现，代码如下

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<set>
#define INF 0x3fffffff
using namespace std;
int value[1050];
int f[1050];
int dp[1050];
set<int>kk,gg;
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        kk.clear();
        for(int i = 1; i < 1050; i++)
            dp[i] = -INF;
        dp[0] = 0;
        int n,total,num;
        scanf("%d%d%d",&n,&total,&num);
        for(int i = 1; i <= n; i++)
            scanf("%d",&value[i]);
        for(int i = 1; i <= n; i++)
            scanf("%d",&f[i]);
        for(int i = 1; i <= n; i++)//!!n个骨头
            for(int j = total; j >= f[i]; j--) {
                    if(dp[j-f[i]] >= 0)
                        dp[j] = max(dp[j],dp[j- f[i]]+value[i]);
                    if(dp[j-f[i]] >= 0 &&dp[j- f[i]]+value[i] >= 0){
                    kk.insert(dp[j- f[i]]+value[i]);
                    gg.insert(dp[j- f[i]]+value[i]);
                }
            }
        int ss = kk.size();
        if(ss < num)cout << 0 <<endl;
        else{
            for(int i = 1; i <= ss-num; i++){
                kk.erase(kk.begin());
            }
            cout << *(kk.begin()) <<endl;
        }
        while(!gg.empty()){
            cout << *gg.begin() << " * ";
            gg.erase(gg.begin());
        }
        cout << endl;
    }
}

但是结果是不对的，因为他存最优解的时候会把丢失掉次优解，比如

5 2

5 3

3 1

这个数据就会失去 8 3这个最优解。

我觉得如果用二位数组实现01背包的话，可能也能到达同样的效果。

贴一下正确的代码：

#include<bits/stdc++.h>
using namespace std;
int dp[1050][32];
int value[1050];
int cost[1050];
int A[35];
int B[35];
bool cmp(int a, int b){
    return a > b;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n,m,kk;
        memset(dp,0,sizeof(dp));
        scanf("%d%d%d",&n,&m,&kk);
        for(int i = 1; i <= n; i++)
            scanf("%d",&value[i]);
        for(int i = 1; i <= n; i++)
            scanf("%d",&cost[i]);
        for(int i = 1; i <= n; i++)
            for(int j = m; j >= cost[i]; j--){

                for(int k = 1;  k <= kk; k++){
                    A[k] = dp[j][k];
                    B[k] = dp[j-cost[i]][k]+value[i];
                }
                A[kk+1] = -9999;
                B[kk+1] = -9999;

                int num = 1, num1 = 1, num2 = 1;
                while(num <= kk && (num1 <= kk || num2 <= kk)){
                    if(A[num1] > B[num2])
                        dp[j][num] = A[num1++];
                    else
                        dp[j][num] = B[num2++];
                    if(dp[j][num] != dp[j][num-1])num++;
                }
            }
        printf("%d\n",dp[m][kk]);
    }
}