杭电oj HDOJ 1203 I NEED A OFFER!（01背包问题）

最新推荐文章于 2021-07-22 10:42:54 发布

Dy66

最新推荐文章于 2021-07-22 10:42:54 发布

阅读量303

点赞数 1

文章标签：算法动态规划 c++

本文链接：https://blog.csdn.net/qq_39880604/article/details/104704004

版权

杭电oj HDOJ 1203 I NEED A OFFER!

题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=1203

Problem Description

Speakless很早就想出国，现在他已经考完了所有需要的考试，准备了所有要准备的材料，于是，便需要去申请学校了。要申请国外的任何大学，你都要交纳一定的申请费用，这可是很惊人的。Speakless没有多少钱，总共只攒了n万美元。他将在m个学校中选择若干的（当然要在他的经济承受范围内）。每个学校都有不同的申请费用a（万美元），并且Speakless估计了他得到这个学校offer的可能性b。不同学校之间是否得到offer不会互相影响。“I NEED A OFFER”，他大叫一声。帮帮这个可怜的人吧，帮助他计算一下，他可以收到至少一份offer的最大概率。（如果Speakless选择了多个学校，得到任意一个学校的offer都可以）。

Input

输入有若干组数据，每组数据的第一行有两个正整数n,m(0<=n<=10000,0<=m<=10000)
后面的m行，每行都有两个数据ai(整型),bi(实型)分别表示第i个学校的申请费用和可能拿到offer的概率。
输入的最后有两个0。

Output

每组数据都对应一个输出，表示Speakless可能得到至少一份offer的最大概率。用百分数表示，精确到小数点后一位。

解题思路

本题属于“01背包”问题，与通常的“01背包”问题不同，本题应该是找出若干个测试用例的概率使 $“ 1 - (1 - 概率 1) (1 - 概率 2) . . . . . . (1 - 概率 i) ”$ 最小，于是我想用“01背包”的动态规划来求解…

设 $o p t (i, n)$ 来表示现可选择测试用例中的前 $i$ 个学校来申请offer且当前剩余 $n$ 万元。具体的递推公式是

当前剩余的钱足够支付申请当前学校offer时： $opt(i,n)=min\begin{Bmatrix}申请：opt(i-1,n-申请当前学校的费用)\times (1-申请当前学校成功的概率) \\ 不申请：opt(i-1,n)\end{Bmatrix}$
当钱剩余的钱不够申请当前学校offer时： $o p t (i, n) = 不申请： o p t (i - 1, n)$

于是我先是使用了递归的方法，尝试一下：

#include <iostream>
#include <algorithm>
#include <iomanip>
using namespace std;

struct school {
	int cost;
	double rate;
};
struct school arr[10001];

double opt(int remain, int i)
{
	double rate1, rate2;
	// 当没有学校可申请或已经没有钱时
	if (!i || !remain) {
		return 1.0;
	}
	// 当剩余的钱不够支付该学校的费用时
	if (remain >= arr[i].cost) {
		// 不申请当前学校的offer
		rate1 = opt(remain, i - 1);
		// 申请当前学校的offer
		rate2 = opt(remain - arr[i].cost, i - 1) * (1 - arr[i].rate);
		return min(rate1, rate2);
	}
	// 当剩余的钱足够支付该学校的费用时
	else {
		return opt(remain, i - 1);
	}
}

int main()
{
	int n, m, i;
	while (cin >> n >> m) {
		if (!n && !m) {
			break;
		}
		for (i = 1; i <= m; i++) {
			cin >> arr[i].cost >> arr[i].rate;
		}
		cout << setiosflags(ios::fixed) << setprecision(1) << (1 - opt(n, m)) * 100 << "%" << endl;
	}
	return 0;
}

不出意料，超时！！！所以我又想用“动态规划表”也就是二位数组来操作一下：

#include <iostream>
#include <algorithm>
#include <iomanip>
using namespace std;

struct school {
	int cost;
	double rate;
};
struct school arr[10001];
double dp[10001][10001];

int main()
{
	int n, m, i, j;
	double rate1, rate2;
	while (cin >> n >> m) {
		if (!n && !m) {
			break;
		}
		for (i = 1; i <= m; i++) {
			cin >> arr[i].cost >> arr[i].rate;
		}
		// 没有钱去申请
		for (i = 0; i <= m; i++) {
			dp[i][0] = 1.0;
		}
		// 没有学校可申请
		for (i = 0; i <= n; i++) {
			dp[0][i] = 1.0;
		}
		for (i = 1; i <= m; i++) {
			for (j = 1; j <= n; j++) {
				// 剩余的前不够申请该学校的offer，只能放弃申请
				if (j < arr[i].cost) {
					dp[i][j] = dp[i - 1][j];
				}
				else {
					// 申请当前学校
					rate1 = dp[i - 1][j - arr[i].cost] * (1 - arr[i].rate);
					// 放弃申请当前学校
					rate2 = dp[i - 1][j];
					dp[i][j] = min(rate1, rate2);
				}
			}
		}
		cout << setiosflags(ios::fixed) << setprecision(1) << (1 - dp[m][n]) * 100 << "%" << endl;
	}
	return 0;
}

然而运行内存爆了！！！因为定义了一个 $10001\times10001$ 的二维数组…最后用了一个“非动态规划的方法”解决了这个问题。

首先思考想要保证 $“ 1 - (1 - 概率 1) (1 - 概率 2) . . . . . . (1 - 概率 i) ”$ 最小，就是要选择尽可能多，尽可能大的概率。所以我们要首先对测试用例进行排序，按概率从大到小排序来保证“尽可能大”的要求，如果概率相同，则把他们按费用从小到大排序来保证“尽可能多”的要求，然后从头循环找出能支付得起的几个“大概率”，带入计算公式得出最后结果。

本人的C++解决方案

#include <iostream>
#include <iomanip>
using namespace std;

struct school {
    int cost;
    double rate;
};

int main()
{
    int n, m , i, j;
    double rate;
    struct school arr[10001], temp;
    while (cin >> n >> m) {
        if (!n && !m) {
            break;
        }
        for (i = 1; i <= m; i++) {
            cin >> arr[i].cost >> arr[i].rate;
        }
        // 冒泡排序
        for (i = 2; i <= m; i++) {
            for (j = 1; j < i; j++) {
                if (arr[j].rate < arr[j + 1].rate) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                else if (arr[j].rate == arr[j + 1].rate){
                    if (arr[j].cost > arr[j + 1].cost) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
        rate = 1;
        for (i = 1; i <= m; i++) {
            if (n >= arr[i].cost) {
                rate *= (1 - arr[i].rate);
                n -= arr[i].cost;
            }
        }
        rate = (1 - rate) * 100;
        cout << setiosflags(ios::fixed) << setprecision(1) << rate << "%" << endl;
    }

    return 0;
}