Cat and Mouse

Cat and Mouse - Problem

Math Dynamic Programming Graph Topological Sort Memoization Game Theory Hard

Imagine a thrilling chase game between a clever Cat and a sneaky Mouse on a connected graph! This is a classic game theory problem that tests your understanding of optimal strategy and dynamic programming.

The Setup:

The graph is represented as graph[a] - a list of all nodes connected to node a
Mouse starts at node 1 and moves first
Cat starts at node 2 and moves second
There's a safe hole at node 0 where the mouse can escape

The Rules:

Players alternate turns, each must move along an edge to a connected node
The Cat cannot enter the hole (node 0)
Cat wins if it catches the mouse (same node)
Mouse wins if it reaches the hole (node 0)
It's a draw if the same game state repeats

Your Goal: Assuming both players play optimally, determine the winner!

Return 1 if mouse wins, 2 if cat wins, or 0 for a draw.

Input & Output

example_1.py — Simple Triangle

$ Input: graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]

› Output: 0

💡 Note: Mouse starts at 1, Cat at 2. Both players play optimally. The mouse can move to 3, and regardless of cat's moves, the game leads to a draw situation where positions repeat.

example_2.py — Mouse Can Win

$ Input: graph = [[1,3],[0,2],[1,3],[0,2]]

› Output: 1

💡 Note: Mouse at 1 can immediately move to 0 (the hole) and win, regardless of what the cat does from position 2.

example_3.py — Cat Dominates

$ Input: graph = [[1,2,3],[0,2],[0,1],[0]]

› Output: 2

💡 Note: The cat at position 2 has strategic advantage and can force a win by controlling key positions and eventually catching the mouse.

Constraints

3 ≤ graph.length ≤ 50
1 ≤ graph[i].length < graph.length
0 ≤ graph[i][j] < graph.length
graph[i][j] ≠ i
graph[i] is unique
The mouse and the cat can always move

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses dynamic programming with topological sorting to determine game outcomes. We work backwards from terminal states (mouse at hole, cat catches mouse) and propagate results using BFS. The key insight is that if a player can move to any winning state, they win; if all moves lead to opponent wins, they lose; otherwise it's a draw. Time complexity: O(N³), space: O(N²).

Common Approaches

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Minimax with Memoization (Optimal)

⏱️ Time: O(N³) Space: O(N²)

This optimal approach uses memoization to store the results of each game state (mouse position, cat position, turn). We work backwards from known winning/losing states using topological sorting or recursive memoization.

Recursive Minimax (Naive)

⏱️ Time: O(N³ × 2^(N²)) Space: O(N²)

This approach uses a simple recursive function to explore all possible game states. For each position, we try all possible moves and recursively determine if the current player can win from any of those positions.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

double solution(int poured, int query_row, int query_glass) {
    // Start with current row containing all champagne in first glass
    double* currentRow = (double*)malloc(sizeof(double));
    currentRow[0] = poured;
    int currentSize = 1;
    
    // Process each row level by level
    for (int row = 0; row < query_row; row++) {
        int nextSize = row + 2;
        double* nextRow = (double*)calloc(nextSize, sizeof(double));
        
        // Process each glass in current row
        for (int glass = 0; glass < currentSize; glass++) {
            if (currentRow[glass] > 1.0) {
                // Calculate overflow and distribute
                double overflow = currentRow[glass] - 1.0;
                currentRow[glass] = 1.0;
                
                // Split overflow equally to two glasses below
                nextRow[glass] += overflow / 2.0;
                nextRow[glass + 1] += overflow / 2.0;
            }
        }
        
        // Move to next row
        free(currentRow);
        currentRow = nextRow;
        currentSize = nextSize;
    }
    
    // Get result and free memory
    double result = (currentRow[query_glass] > 1.0) ? 1.0 : currentRow[query_glass];
    free(currentRow);
    
    return result;
}

int main() {
    int poured, query_row, query_glass;
    scanf("%d", &poured);
    scanf("%d", &query_row);
    scanf("%d", &query_glass);
    
    double result = solution(poured, query_row, query_glass);
    printf("%f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~45 min Avg. Time

892 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