Mice and Cheese - Practice Coding Problems

Mice and Cheese - Problem

Imagine you have two hungry mice and n different types of delicious cheese spread out before them. Each cheese must be eaten by exactly one mouse - no sharing allowed!

Here's the twist: each mouse has different taste preferences! For cheese i, the first mouse gets reward1[i] points of satisfaction, while the second mouse gets reward2[i] points.

Your goal: Distribute the cheese optimally so that the first mouse eats exactly k types of cheese, and the total satisfaction points are maximized.

Example: If reward1 = [1,1,3,4], reward2 = [4,4,1,1], and k = 2, the optimal strategy is to give cheese types 2 and 3 to the first mouse (earning 3+4=7 points) and types 0 and 1 to the second mouse (earning 4+4=8 points), for a total of 15 points.

Input & Output

example_1.py — Basic Example

$ Input: reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2

› Output: 15

💡 Note: The advantages are [-3,-3,2,3]. After sorting by advantage: cheese 3 (adv +3), cheese 2 (adv +2), cheese 0 (adv -3), cheese 1 (adv -3). Mouse 1 gets cheese 3 and 2 (4+3=7 points), Mouse 2 gets cheese 0 and 1 (4+4=8 points). Total = 15.

example_2.py — All Positive Advantages

$ Input: reward1 = [1,1], reward2 = [1,1], k = 1

› Output: 2

💡 Note: Both cheese have advantage 0, so it doesn't matter which one mouse 1 gets. Mouse 1 gets 1 cheese (1 point), Mouse 2 gets 1 cheese (1 point). Total = 2.

example_3.py — Edge Case k=0

$ Input: reward1 = [1,2,3], reward2 = [3,2,1], k = 0

› Output: 6

💡 Note: Mouse 1 gets no cheese (k=0), so Mouse 2 gets all cheese types and earns 3+2+1=6 points.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ reward1[i], reward2[i] ≤ 1000
0 ≤ k ≤ n
Each cheese must be eaten by exactly one mouse

Visualization

Tap to expand

Understanding the Visualization

Calculate Opportunity Costs

For each cheese, calculate what we gain/lose by giving it to mouse 1 instead of mouse 2

Rank by Priority

Sort all cheese types by their advantage values - highest advantage first

Make Greedy Choices

Assign the k most advantageous cheese types to mouse 1, rest to mouse 2

Key Takeaway

🎯 Key Insight: By thinking in terms of 'advantage' or 'opportunity cost', we can make locally optimal decisions that lead to the globally optimal solution. This greedy approach works because we're maximizing the total benefit across both mice.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a greedy approach with sorting. Calculate the advantage of giving each cheese to mouse 1 versus mouse 2 (advantage[i] = reward1[i] - reward2[i]). Sort cheese by advantage in descending order, then assign the top k most advantageous cheese types to mouse 1 and the rest to mouse 2. This achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * n)	O(k)	Try every possible way to choose k cheese types for the first mouse
Greedy with Sorting (Optimal)	O(n log n)	O(n)	Sort cheese by advantage difference and greedily pick top k for mouse 1

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k indices from 0 to n-1
For each combination, calculate total score: sum of reward1[i] for chosen indices + sum of reward2[j] for remaining indices
Keep track of the maximum score found
Return the maximum score

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose k cheese types from n total types

Calculate Score

For each combination, sum rewards for mouse 1 (chosen types) and mouse 2 (remaining types)

Track Maximum

Keep track of the highest total score found across all combinations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int miceAndCheese(int* reward1, int* reward2, int n, int k) {
    int maxScore = 0;
    
    // Generate all combinations using bit manipulation
    for (int mask = 0; mask < (1 << n); mask++) {
        if (popcount(mask) == k) {
            int score = 0;
            for (int i = 0; i < n; i++) {
                if (mask & (1 << i)) {
                    score += reward1[i];
                } else {
                    score += reward2[i];
                }
            }
            if (score > maxScore) {
                maxScore = score;
            }
        }
    }
    
    return maxScore;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int* reward1 = malloc(n * sizeof(int));
    int* reward2 = malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &reward1[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &reward2[i]);
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", miceAndCheese(reward1, reward2, n, k));
    
    free(reward1);
    free(reward2);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * n)

We generate C(n,k) combinations, and for each combination we spend O(n) time calculating the score

✓ Linear Growth

Space Complexity

O(k)

We only need space to store the current combination being evaluated

✓ Linear Space

47.2K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler