HDU 2955 Robberies(01背包问题)

Robberies

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

Problem Description
The aspiring Roy the Robber has seen a lot of American movies, and knows that the bad guys usually gets caught in the end, often because they become too greedy. He has decided to work in the lucrative business of bank robbery only for a short while, before retiring to a comfortable job at a university.

For a few months now, Roy has been assessing the security of various banks and the amount of cash they hold. He wants to make a calculated risk, and grab as much money as possible.

His mother, Ola, has decided upon a tolerable probability of getting caught. She feels that he is safe enough if the banks he robs together give a probability less than this.

Input
The first line of input gives T, the number of cases. For each scenario, the first line of input gives a floating point number P, the probability Roy needs to be below, and an integer N, the number of banks he has plans for. Then follow N lines, where line j gives an integer Mj and a floating point number Pj .
Bank j contains Mj millions, and the probability of getting caught from robbing it is Pj .

Output
For each test case, output a line with the maximum number of millions he can expect to get while the probability of getting caught is less than the limit set.

Notes and Constraints
0 < T <= 100
0.0 <= P <= 1.0
0 < N <= 100
0 < Mj <= 100
0.0 <= Pj <= 1.0
A bank goes bankrupt if it is robbed, and you may assume that all probabilities are independent as the police have very low funds.

Sample Input
3
0.04 3
1 0.02
2 0.03
3 0.05
0.06 3
2 0.03
2 0.03
3 0.05
0.10 3
1 0.03
2 0.02
3 0.05

Sample Output
2
4
6

解题思路：
本题利用01背包解决。不过稍微运用了一下逆向思维。如果按照经典的思路，应该是概率作为容量，钱数作为价值，
但是由于概率是浮点数，不能直接当做下标来使用，因此不妨换一个角度来考虑：概率作为价值，钱数作为容量。我们把所有的概率都转化为不被抓的概率，那么，本题实际上是求解不被抓的概率刚刚大于P的时候，最大的容量是多少。这样就可以用经典的01背包求解了。
用dp[i][j]表示将在前i个银行偷到的钱放入容量为j的背包中不被抓的概率，则状态转移方程为：
dp[i][j] = max{dp[i-1][j], dp[i-1][j-v[i]]x(1-p[i])};
v[i]为第i个银行的钱，1-p[i]即不被抓的概率。
由于是独立事件，所以要用累乘。
初始条件：dp[i][0]=1,其余dp[i][j]=0,i!=0。为什么不是dp[0][i]=1呢？因为一个银行都不去，怎么偷到钱呢？矛盾。
　　最终通过从总钱数递减找到第一个大于等于期望的不被捕概率(1-p)的背包，即为不被逮捕的所能抢到的最大钱数。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;

const int nmax=101;
int v[nmax];
double p[nmax];
double dp[nmax][100000];

void FindMax(int number, int capacity)//动态规划
{
    int i,j;
    //填表
    for(i=1;i<=number;i++)
        for(j=1;j<=capacity;j++)
        {
            if(j<v[i])//包装不进
                dp[i][j]=dp[i-1][j];
            else//能装
				dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]*(1-p[i]));
        }
}

int main()
{
	freopen("in.txt", "r", stdin);
	int T;
	cin>>T;
	while(T--)
	{
		double p_num;
		int num, m_sum=0;
		cin>>p_num>>num;
		for(int i=1;i<=num;i++)
		{
			cin>>v[i]>>p[i];
			m_sum += v[i];
		}
//		memset(dp, 0, sizeof(dp)/sizeof(double));
		for(int i=0;i<=num;i++)
			for(int j=0;j<=m_sum;j++)
				dp[i][j] = 0;
		for(int i=0;i<=num;i++)
			dp[i][0] = 1;
		FindMax(num, m_sum);
		int flag = 1;
		for(int j=m_sum;j>=1;j--)
			if(dp[num][j]-(1-p_num)>1e-10)
			{
				cout<<j<<endl;
				flag = 0;
				break;
			}
		if(flag)
			cout<<"0"<<endl;
	}
	return 0;
}

上面的代码已在杭电oj中通过，下面是对这个题目做一些补充。
问题1：怎么找到这个匪徒到底抢了哪几家银行呢？

void FindWhat(int i,int j)//寻找解的组成方式
{
    if(i>0)
    {
        if(dp[i][j]==dp[i-1][j])//相等说明没装
        {
            item[i]=0;//全局变量，标记未被选中
            FindWhat(i-1,j);
        }
        else if(j-v[i]>=0 && (fabs(dp[i][j]-dp[i-1][j-v[i]]*(1-p[i]))<0.00001))
        {
            item[i]=1;//标记已被选中
            FindWhat(i-1,j-v[i]);//回到装包之前的位置
        }
    }
}

问题2：如何进行空间优化？

#include<iostream>
#include<cmath>
#include <cstring>
#include<algorithm>
using namespace std;
const int nmax=101;
int v[nmax];
double p[nmax];
double dp[100000];
int main()
{
	freopen("in.txt", "r", stdin);
	int t;
	cin>>t;
	while(t--)
	{
		double p_sum;
		int n;
		cin>>p_sum>>n;
		int sum=0;
		for(int i=1;i<=n;i++)
		{
			cin>>v[i]>>p[i];
			//p[i]*=10;
			sum+=v[i];
		}
		memset(dp, 0, sizeof(dp));
		dp[0]=1;
		for(int i=1;i<=n;i++)
			for(int j=sum;j>=v[i];j--)
			{
				dp[j]=max(dp[j],dp[j-v[i]]*(1-p[i]));
			}
		for(int i=sum;i>=0;i--){
//			cout<<dp[i]<<endl;
			if(dp[i]>(1-p_sum))
			{
				cout<<i<<endl;
				break;
			}
		}
	}
	return 0;
}