Cat and Mouse II - Practice Coding Problems

Cat and Mouse II - Problem

Array Math Dynamic Programming Graph Topological Sort Memoization Matrix Game Theory Hard

Welcome to an exciting game theory problem! Imagine a strategic battle between a clever mouse and a cunning cat on a grid-based playing field.

The Setup: We have a rows × cols grid where:

'M' represents the Mouse (starts first)
'C' represents the Cat
'F' represents the Food (the ultimate prize!)
'.' represents walkable floor tiles
'#' represents impassable walls

Game Rules:

Mouse moves first, then they alternate turns
Each player can jump up to mouseJump or catJump steps in any cardinal direction
Players can choose to stay in place or jump any distance ≤ their max jump
Mouse can jump over the cat (but not walls!)

Victory Conditions:

Cat wins if: Cat catches mouse OR cat reaches food first OR 1000+ turns pass
Mouse wins if: Mouse reaches food before cat and avoids capture

Your Mission: Determine if the mouse can guarantee a win with optimal play from both players.

Input & Output

example_1.py — Python

$ Input: grid = ["####F","#C...","M...."] catJump = 1, mouseJump = 2

› Output: true

💡 Note: Mouse can win by jumping 2 steps right to (2,2), then the cat can only move 1 step and cannot catch up. Mouse continues toward food while staying ahead of the slower cat.

example_2.py — Python

$ Input: grid = ["M.C...F"] catJump = 1, mouseJump = 4

› Output: true

💡 Note: Mouse can jump 4 spaces directly to (0,4), then 2 more to reach food at (0,6). Cat can only move 1 space per turn and cannot prevent mouse from reaching food first.

example_3.py — Python

$ Input: grid = ["C...#....", ".........", "#.....#..", "..M.....F"] catJump = 2, mouseJump = 5

› Output: false

💡 Note: Even with mouse's superior jump distance, the cat can position itself strategically to either catch the mouse or reach the food first through optimal play.

Visualization

Tap to expand

Understanding the Visualization

Game State Analysis

For each position combination, determine if mouse can guarantee a win

Minimax Decision

Mouse chooses moves that maximize winning chances, cat minimizes them

Memoization Optimization

Cache results to avoid recalculating identical game states

Optimal Play Result

Return whether mouse can win with perfect play from both sides

Key Takeaway

🎯 Key Insight: Game theory problems require analyzing optimal play from both sides. Memoization transforms exponential minimax into efficient polynomial solution by caching computed game states.

Time & Space Complexity

Time Complexity

⏱️

O(rows × cols × rows × cols × T)

We have at most rows×cols positions for mouse, rows×cols for cat, T turns (≤1000), and 2 turn types. Each unique state is calculated once.

✓ Linear Growth

Space Complexity

O(rows × cols × rows × cols × T)

Memoization cache stores results for each unique game state combination

✓ Linear Space

Constraints

rows == grid.length
cols == grid[i].length
1 ≤ rows, cols ≤ 8
grid[i][j] consist only of characters 'C', 'M', 'F', '.', and '#'
There is only one of each character 'C', 'M', and 'F' in grid
1 ≤ catJump, mouseJump ≤ 8
Important: Game ends after 1000 turns if mouse hasn't won

Asked in

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

The optimal solution uses dynamic programming with memoization to analyze this game theory problem. We implement minimax algorithm where the mouse maximizes winning probability while the cat minimizes it. By caching results for each (mouse_pos, cat_pos, turn, player) state combination, we transform an exponential brute force approach into an efficient polynomial solution that handles the complex strategic gameplay optimally.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(rows × cols × rows × cols × T)	O(rows × cols × rows × cols × T)	Use memoization to cache game state results and avoid redundant calculations
Brute Force Recursive Minimax	O((rows×cols)^k)	O(k)	Explore all possible game states recursively without memoization

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization cache for game states: (mouse_pos, cat_pos, turn, is_mouse_turn)
Implement minimax with memoization - check cache before computing
For each state, try all valid moves for the current player
Mouse maximizes winning probability, cat minimizes it
Store computed results in cache before returning
Handle base cases: capture, food reached, turn limit exceeded

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Computation

First time calculating a game state - store result in cache

Cache Hit

When same state appears again, return cached result immediately

Efficiency Gain

Dramatic reduction in computation time by avoiding redundant calculations

Code -

solution.c — C

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

#define MAX_CACHE 100000

typedef struct {
    int r, c;
} Position;

typedef struct {
    Position mousePos, catPos;
    bool isMouseTurn;
    int turns;
    bool result;
    bool valid;
} CacheEntry;

static char** grid_global;
static int rows_global, cols_global;
static Position food_pos;
static CacheEntry cache[MAX_CACHE];
static int cache_size = 0;

int hashState(Position mousePos, Position catPos, bool isMouseTurn, int turns) {
    return (mousePos.r * 1000 + mousePos.c * 100 + catPos.r * 10 + catPos.c + (isMouseTurn ? 1 : 0) * 10000 + turns) % MAX_CACHE;
}

bool findInCache(Position mousePos, Position catPos, bool isMouseTurn, int turns, bool* result) {
    int hash = hashState(mousePos, catPos, isMouseTurn, turns);
    if (cache[hash].valid && 
        cache[hash].mousePos.r == mousePos.r && cache[hash].mousePos.c == mousePos.c &&
        cache[hash].catPos.r == catPos.r && cache[hash].catPos.c == catPos.c &&
        cache[hash].isMouseTurn == isMouseTurn && cache[hash].turns == turns) {
        *result = cache[hash].result;
        return true;
    }
    return false;
}

void addToCache(Position mousePos, Position catPos, bool isMouseTurn, int turns, bool result) {
    int hash = hashState(mousePos, catPos, isMouseTurn, turns);
    cache[hash].mousePos = mousePos;
    cache[hash].catPos = catPos;
    cache[hash].isMouseTurn = isMouseTurn;
    cache[hash].turns = turns;
    cache[hash].result = result;
    cache[hash].valid = true;
}

Position* getMoves(Position pos, int jumpDist, int* moveCount) {
    Position* moves = malloc(sizeof(Position) * 1000);
    *moveCount = 0;
    moves[(*moveCount)++] = pos;
    
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    for (int i = 0; i < 4; i++) {
        for (int dist = 1; dist <= jumpDist; dist++) {
            int nr = pos.r + directions[i][0] * dist;
            int nc = pos.c + directions[i][1] * dist;
            if (nr >= 0 && nr < rows_global && nc >= 0 && nc < cols_global && 
                grid_global[nr][nc] != '#') {
                moves[(*moveCount)++] = (Position){nr, nc};
            } else {
                break;
            }
        }
    }
    return moves;
}

bool minimax(Position mousePos, Position catPos, bool isMouseTurn, int turns, int mouseJump, int catJump) {
    bool cached_result;
    if (findInCache(mousePos, catPos, isMouseTurn, turns, &cached_result)) {
        return cached_result;
    }
    
    if (mousePos.r == catPos.r && mousePos.c == catPos.c) {
        addToCache(mousePos, catPos, isMouseTurn, turns, false);
        return false;
    }
    if (mousePos.r == food_pos.r && mousePos.c == food_pos.c) {
        addToCache(mousePos, catPos, isMouseTurn, turns, true);
        return true;
    }
    if (catPos.r == food_pos.r && catPos.c == food_pos.c) {
        addToCache(mousePos, catPos, isMouseTurn, turns, false);
        return false;
    }
    if (turns >= 1000) {
        addToCache(mousePos, catPos, isMouseTurn, turns, false);
        return false;
    }
    
    bool result;
    int moveCount;
    if (isMouseTurn) {
        result = false;
        Position* moves = getMoves(mousePos, mouseJump, &moveCount);
        for (int i = 0; i < moveCount; i++) {
            if (minimax(moves[i], catPos, false, turns + 1, mouseJump, catJump)) {
                result = true;
                break;
            }
        }
        free(moves);
    } else {
        result = true;
        Position* moves = getMoves(catPos, catJump, &moveCount);
        for (int i = 0; i < moveCount; i++) {
            if (!minimax(mousePos, moves[i], true, turns + 1, mouseJump, catJump)) {
                result = false;
                break;
            }
        }
        free(moves);
    }
    
    addToCache(mousePos, catPos, isMouseTurn, turns, result);
    return result;
}

bool canMouseWin(char** grid, int gridSize, int* gridColSize, int catJump, int mouseJump) {
    grid_global = grid;
    rows_global = gridSize;
    cols_global = gridColSize[0];
    memset(cache, 0, sizeof(cache));
    cache_size = 0;
    
    Position mousePos, catPos;
    for (int i = 0; i < rows_global; i++) {
        for (int j = 0; j < cols_global; j++) {
            if (grid[i][j] == 'M') mousePos = (Position){i, j};
            else if (grid[i][j] == 'C') catPos = (Position){i, j};
            else if (grid[i][j] == 'F') food_pos = (Position){i, j};
        }
    }
    
    return minimax(mousePos, catPos, true, 0, mouseJump, catJump);
}

Time & Space Complexity

Time Complexity

⏱️

O(rows × cols × rows × cols × T)

We have at most rows×cols positions for mouse, rows×cols for cat, T turns (≤1000), and 2 turn types. Each unique state is calculated once.

✓ Linear Growth

Space Complexity

O(rows × cols × rows × cols × T)

Memoization cache stores results for each unique game state combination

✓ Linear Space

Constraints

rows == grid.length
cols == grid[i].length
1 ≤ rows, cols ≤ 8
grid[i][j] consist only of characters 'C', 'M', 'F', '.', and '#'
There is only one of each character 'C', 'M', and 'F' in grid
1 ≤ catJump, mouseJump ≤ 8
Important: Game ends after 1000 turns if mouse hasn't won

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler