USACO 2022 December Contest，Gold题解

Prob1

(Analysis by Timothy Feng)

Define dp[i][j][k]dp[i][j][k] to be the maximum amount of popularity Bessie can achieve with her friends 1…i1…i, jj moonies, and kk ice cream cones.

• If Bessie does not want to bribe cow ii, then we can update dp[i+1][j][k]=dp[i][j][k]dp[i+1][j][k]=dp[i][j][k].
• If Bessie chooses to bribe cow ii, she can optionally spend some ice cream cones to decrease her cost. Loop through 0…k0…k to brute force how many ice cream cones Bessie will spend on cow ii. If Bessie chooses to spend cc cones, then Bessie needs to spend Ci−⌊cXi⌋Ci−⌊cXi⌋ moonies. Therefore, dp[i+1][j−(Ci−⌊cXi⌋)][k−c]=dp[i][j][k]dp[i+1][j−(Ci−⌊cXi⌋)][k−c]=dp[i][j][k].

However, this code runs in O(NAB2)O(NAB2) time.

To do better, suppose that we already know the set of cows that we plan to take. How do we check that inviting these cows is within our budget? We can do this greedily. Start by not spending any cones at all, and spending only money to invite these cows. This might cost more money than we have. Next, we will try to spend some ice cream cones to reduce the amount of money we need to spend. Note that at this point, we would always choose the cow with the smallest XiXi to decrease the total cost most efficiently. In other words, the cows that we bribe with cones is a prefix of all cows when sorted by XiXi. This observation leads us to the fact that for each jj and kk, to choose a new cow ii, we only have one transition to consider. Sort Bessie's friends by increasing XiXi. Note that if we take cow ii, we want to spend all our ice cream cones first before we move on to spending money, so we would use c=min(k,Ci⋅Xi)c=min(k,Ci⋅Xi) cones and Ci−⌊cXi⌋Ci−⌊cXi⌋ moonies. Due to the O(NAB)O(NAB) states we have, this results in an O(NAB)O(NAB) time dp.

We can further remove one dimension. By the same observation from before - that cones are used to the maximum before moonies - for all dp states, either kk equals zero or jj equals AA. For each ii, we now only consider O(A+B)O(A+B) states, leading us to our final O(N(A+B))O(N(A+B)) solution.

定义 dp[i][j][k]dp[i][j][k] 为贝茜与她的 1…i1…i 个朋友、jj 个月之神和 kk 个冰淇淋获得的最大人气值。

• 如果贝茜不想收买第 ii 头奶牛，那么我们可以更新 dp[i+1][j][k]=dp[i][j][k]dp[i+1][j][k]=dp[i][j][k]。
• 如果贝茜选择行贿第 ii 头奶牛，她可以选择花费一些冰淇淋来降低成本。循环遍历 0…k0…k 来暴力计算贝茜将在第 ii 头奶牛身上花费多少冰淇淋。如果贝茜选择花费 cc 个冰淇淋，则她需要花费 Ci−⌊cXi⌋Ci−⌊cXi⌋ 个月之神进行收买。因此，dp[i+1][j−(Ci−⌊cXi⌋)][k−c]=dp[i][j][k]dp[i+1][j−(Ci−⌊cXi⌋)][k−c]=dp[i][j][k]。

然而，这份代码的时间复杂度为 O(NAB2)O(NAB2)。

为了更好地解决问题，假设我们已经知道要考虑的奶牛集合。我们如何检查邀请这些奶牛是否在我们的预算内？我们可以贪心地解决这个问题，从不花费任何冰淇淋开始，只花费金钱邀请这些奶牛，这可能会花费更多金钱。接下来，我们将尝试花费一些冰淇淋来减少我们需要花费的金钱。注意，在这个阶段，我们总是选择 XiXi 最小的奶牛来最有效地降低总成本。换句话说，通过 XiXi 排序之后，使用冰淇淋贿赂的奶牛是所有奶牛的前缀。这个观察让我们得出一个结论：对于每个 jj 和 kk，选择一个新的奶牛 ii，我们只有一个转移需要考虑。按 XiXi 递增排序贝茜的朋友。注意，如果我们选择奶牛 ii，我们会先花光所有的冰淇淋，然后再花费金钱，所以我们会使用 c=min(k,Ci⋅Xi)c=min(k,Ci⋅Xi) 份冰淇淋和 Ci−⌊cXi⌋Ci−⌊cXi⌋ 月之神的费用。由于我们拥有 O(NAB)O(NAB) 种状态，因此这导致了一个 O(NAB)O(NAB) 的时间复杂度。

我们可以进一步去掉一个维度。根据之前的观察，冰淇淋在花尽之前被最大限度地使用，因此对于所有的dp状态，kk 要么等于 00，要么 jj 等于 AA。对于每个 ii，我们现在只考虑 O(A+B)O(A+B) 个状态，这使我们得出最终的 O(N(A+B))O(N(A+B)) 解。

Timothy's C++ code:

#include <bits/stdc++.h>
using namespace std;

const int N = 2000 + 1;

int dp[N][2 * N];

void set_max(int &a, int b) {
    if (b > a) a = b;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, moonie, cones;
    cin >> n >> moonie >> cones;

    vector<array<int, 3>> cows(n);
    for (auto &[x, p, c] : cows) {
        cin >> p >> c >> x;
    }
    sort(cows.begin(), cows.end());

    memset(dp, -1, sizeof dp);

    dp[0][moonie + cones] = 0;
    for (int i = 0; i < n; ++i) {
        auto [x, p, c] = cows[i];
        for (int j = 0; j <= moonie + cones; ++j) {
            if (dp[i][j] == -1) continue;

            set_max(dp[i + 1][j], dp[i][j]);
            if (j - c * x >= moonie) {
                set_max(dp[i + 1][j - c * x], dp[i][j] + p);
            } else if (j > moonie) {
                int cost_left = c - (j - moonie) / x;
                if (moonie - cost_left >= 0)
                    set_max(dp[i + 1][moonie - cost_left], dp[i][j] + p);
            } else if (j <= moonie && j - c >= 0) {
                set_max(dp[i + 1][j - c], dp[i][j] + p);
            }
        }
    }

    cout << *max_element(dp[n], dp[n] + moonie + cones + 1) << "n";
}

Nick Wu's Python code:

n, a, b = (int(x) for x in input().split())
dpmoney = [0] * (a+1)
dpcones = [0] * (b+1)
v = sorted([[int(x) for x in input().split()] for _ in range(n)], key =