携程笔试-2023.3.7-第四题:游游买商品(动态规划、记忆化搜索)

题目内容

游游正在进超市，有 n 个商品摆成一排，第 i 个商品的价格为 ai ，游游对它的喜爱度为 bi 。所有商品的价格都是偶数。

超市开展了一个活动，当游游花费原价买了一件商品时，她可以用半价买下一件右边相邻的商品(也可以用原价购买，这样该商品右边的商品就有次享受半价的机会)。但如果游游半价购买了一件商品，那么下一件右边相邻的商品只能原价购买。

换言之，如果游游想要半价买某一件商品，必须先用原价买下它相邻的左边的那个商品游游

初始的钱为 x ，她想要买的商品的喜爱度总和尽可能大，但总价格不能超过 x 。你能帮帮她计算最大的喜爱度总和吗？

输入描述

第一行输入两个正整数 n 和 x ，分别代表商品的数量，以及游游初始的金额数。

第二行输入 n 个正整数 ai ，分别代表每个商品的价格。

第三行输入 n 个正整数 bi ，分别代表每个商品可以给游游带来的喜爱度。

1≤n,x,ai≤1000

1≤bi≤ 1e9 保证所有的 ai 都是偶数。

输出描述

一个整数，代表最终喜爱度之和的最大值。

样例

样例一

输入

4 7
2 2 6 2
3 4 5 1

输出

12

样例解释

第一个使用原价买，第二个物品使用原价买，第三个物品使用半价买，不买第四个物品，这样是最优的。

请注意，如果第二个物品使用了半价，那么第三个物品则不能使用半价。

样例二

输入

3 3
4 10 6
3 2 4

输出

0

样例解释

钱不够，无法购买任何物品。

思路

动态规划

相比之前的背包加一个维度，0表示不买,1表示买,2表示半价买

dp[i][j][2]=dp[i-1][j-a[i]/2][1]+b[i]

dp[i][j][1]=max(dp[i-1][j-a[i]][0~2])+b[i]

dp[i][j][0]=max(dp[i-1][j][0~2])

结果取最大值就可以了.

记忆化搜索

普通搜索的代码比较简单, 但是他没有保存子问题的结果,每次调用都会重新计算, 导致时间复杂度过高, 所以会造成超时.

代码

动态规划代码

#include

using namespace std;

const int N = 1000 + 100;

int dp[N][N][3];
int a[N], b[N];

int main()
{
    int n, x;
    cin >> n >> x;

    for (int i = 1; i <= n; i ++) cin >> a[i];
    for (int i = 1; i <= n; i ++) cin >> b[i];

    memset(dp, 0, sizeof dp);

    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = 0; j <= x; j ++) {
            // 不买
            dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
            dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][2]);
            // 全价买（上一步的半价 + 上一步没买 + 上一步半价）
            if (j >= a[i]) {
                dp[i][j][1] = dp[i - 1][j - a[i]][0] + b[i];
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - a[i]][1] + b[i]);
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - a[i]][2] + b[i]);
            }
            // 半价买(需要上一步全价)
            if (j - a[i]/2 >= 0 && dp[i - 1][j - a[i] / 2][1] > 0) {
                dp[i][j][2] = max(dp[i][j][2], dp[i - 1][j - a[i] / 2][1] + b[i]);
            }

            ans = max(ans, dp[i][j][0]);
            ans = max(ans, dp[i][j][1]);
            ans = max(ans, dp[i][j][2]);
        }

    }

    cout << ans << endl;
    return 0;
}

记忆化搜索代码

#include

using namespace std;

const int N = 1000 + 100;

int a[N], b[N];
int n, x;
int memo[N][N][2]; // memo[i][j][0/1]: 前i个物品，剩余价值为j，上一个买的物品是全价买（1）/半价买（0）时的最大价值

int dfs(int u, int remain, bool half) {
    if (u > n) return 0;
    if (memo[u][remain][half] != 0) return memo[u][remain][half]; // 如果已经计算过，直接返回
    int r = dfs(u + 1, remain, false);
    if (remain >= a[u])
        r = max(r, dfs(u + 1, remain - a[u], true) + b[u]);
    if (remain >= a[u] / 2 && half)
        r = max(r, dfs(u + 1, remain - a[u] / 2, false) + b[u]);
    memo[u][remain][half] = r; // 保存结果
    return r;
}

int main() {
    cin >> n >> x;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    cout << dfs(1, x, false) << endl;
    return 0;
}