2019 Dec Bronze Problem 1 Cow Gymnastics

Official Problem Statement

Cow Gymnastics

Problem Statement

Cow Gymnastics is a USACO problem from the December 2020 contest.

The problem statement is as follows:

Farmer John has N cows (1 ≤ N ≤ 100,000) that he wants to train for a gymnastics competition. Each cow i has a skill level Si (1 ≤ Si ≤ 1,000,000,000).

FJ has M exercises (1 ≤ M ≤ 100,000) that he can use to train his cows. Each exercise j has a difficulty level Dj (1 ≤ Dj ≤ 1,000,000,000).

FJ wants to assign each cow to exactly one exercise. He wants to maximize the total skill level of all cows, but he also wants to make sure that the total difficulty of the exercises assigned to his cows is as small as possible.

Help FJ determine the maximum total skill level of his cows that can be achieved.

Solution

The solution to this problem can be found using a dynamic programming approach. We create an array dp[i][j] which stores the maximum total skill level of cows that can be achieved when considering the first i cows and the first j exercises. We initialize the array with dp[0][0] = 0.

Then, for each i and j, we consider two cases:

Case 1: We assign the ith cow to the jth exercise. In this case, the maximum total skill level of cows that can be achieved is dp[i-1][j-1] + Si.

Case 2: We do not assign the ith cow to the jth exercise. In this case, the maximum total skill level of cows that can be achieved is dp[i][j-1].

We take the maximum of these two cases and store it in dp[i][j].

Finally, the answer to the problem is dp[N][M], which is the maximum total skill level of cows that can be achieved when considering all N cows and all M exercises.

The following is a C++ implementation of this solution:

int N, M;
int S[MAXN], D[MAXM];
int dp[MAXN][MAXM];

int main() {
    cin >> N >> M;
    for (int i = 0; i < N; i++) cin >> S[i];
    for (int j = 0; j < M; j++) cin >> D[j];
    
    dp[0][0] = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            dp[i][j] = max(dp[i-1][j-1] + S[i], dp[i][j-1]);
        }
    }
    
    cout << dp[N][M] << endl;
    
    return 0;
}