Cat and Mouse - Practice Coding Problems

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

Understanding the Visualization

Identify Terminal States

Mark states where mouse reaches hole (mouse wins) or cat catches mouse (cat wins)

Build State Graph

Create a graph of all possible game states (mouse pos, cat pos, turn)

Propagate Backwards

Use BFS to determine outcomes of parent states based on child outcomes

Apply Minimax Logic

Current player wins if any move leads to victory; loses if all moves lead to opponent victory

Key Takeaway

🎯 Key Insight: Use backwards induction from terminal states - if a player has any winning move available, they'll take it; if all moves lead to opponent wins, they lose; otherwise it's a draw.

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

Approach	Time	Space	Notes
✓ Recursive Minimax (Naive)	O(N³ × 2^(N²))	O(N²)	Recursively try all possible moves for both players
Minimax with Memoization (Optimal)	O(N³)	O(N²)	Use dynamic programming to cache results and avoid recomputation

Recursive Minimax (Naive) — Algorithm Steps

Define a recursive function that takes current mouse position, cat position, and whose turn it is
Base cases: if mouse reached hole (mouse wins), if cat caught mouse (cat wins)
For each possible move, recursively check the outcome
Mouse tries to find a winning move, Cat tries to find a winning move
If no winning move exists, check for draw, otherwise opponent wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Mouse at 1, Cat at 2, Mouse's turn

Explore Moves

Try all possible mouse moves recursively

Cat Responds

For each mouse move, cat tries all its moves

Determine Winner

Backtrack to find optimal strategy

Code -

solution.c — C

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

int dfs(int mouse, int cat, int turn, int** graph, int* graphColSize) {
    if (mouse == 0) return 1;  // Mouse wins
    if (mouse == cat) return 2;  // Cat wins
    
    if (turn == 1) {  // Mouse's turn
        int catWins = 1;
        for (int i = 0; i < graphColSize[mouse]; i++) {
            int nextMouse = graph[mouse][i];
            int result = dfs(nextMouse, cat, 2, graph, graphColSize);
            if (result == 1) return 1;
            if (result != 2) catWins = 0;
        }
        return catWins ? 2 : 0;
    } else {  // Cat's turn
        int mouseWins = 1;
        for (int i = 0; i < graphColSize[cat]; i++) {
            int nextCat = graph[cat][i];
            if (nextCat == 0) continue;
            int result = dfs(mouse, nextCat, 1, graph, graphColSize);
            if (result == 2) return 2;
            if (result != 1) mouseWins = 0;
        }
        return mouseWins ? 1 : 0;
    }
}

int catMouseGame(int** graph, int graphSize, int* graphColSize) {
    return dfs(1, 2, 1, graph, graphColSize);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N³ × 2^(N²))

N³ possible states times exponential branching factor due to lack of memoization

✓ Linear Growth

Space Complexity

O(N²)

Recursion depth proportional to number of moves before cycle detection

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Minimax (Naive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler