Alice and Bob Playing Flower Game - Practice Coding Problems

Alice and Bob Playing Flower Game - Problem

Math Medium

Alice and Bob are playing a strategic flower-picking game! 🌸

The game setup is elegant: there are two parallel lanes of flowers between Alice and Bob. Lane 1 has x flowers and Lane 2 has y flowers.

Game Rules:
• Alice always goes first
• On each turn, a player picks exactly one flower from either lane
• The player who picks the last flower from both lanes (making both lanes empty) wins

Your Mission: Given constraints n and m, count how many starting configurations (x, y) guarantee Alice will win with optimal play, where:
• 1 ≤ x ≤ n (flowers in lane 1)
• 1 ≤ y ≤ m (flowers in lane 2)

This is a classic game theory problem where we need to determine winning and losing positions!

Input & Output

example_1.py — Small Game

$ Input: n = 3, m = 2

› Output: 3

💡 Note: Alice wins with configurations: (1,2), (2,1), (3,2). In each case, the total flowers x+y is odd (3, 3, 5 respectively), so Alice makes the final move and wins.

example_2.py — Larger Game

$ Input: n = 4, m = 4

› Output: 8

💡 Note: Alice wins when x+y is odd. Pairs: (1,2), (1,4), (2,1), (2,3), (3,2), (3,4), (4,1), (4,3). Total: 8 winning configurations.

example_3.py — Edge Case

$ Input: n = 1, m = 1

› Output: 0

💡 Note: Only one configuration (1,1) where x+y=2 is even. Bob wins because Alice starts but Bob makes the final move (move #2).

Visualization

Tap to expand

Understanding the Visualization

Game Setup

Two lanes with x and y flowers, Alice goes first

Optimal Play

Both players play perfectly, making the best possible moves

Parity Insight

Alice wins ⟺ she makes the final move ⟺ (x+y) is odd

Mathematical Count

Count configurations where x+y is odd using parity formula

Key Takeaway

🎯 Key Insight: Game theory transforms a complex simulation problem into elegant mathematics - Alice wins precisely when the total flowers (x + y) is odd!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Simple arithmetic calculation using the parity pattern

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for the calculation

✓ Linear Space

Constraints

1 ≤ n, m ≤ 10⁵
Both n and m are positive integers
Time limit: 1 second per test case

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses game theory analysis to discover that Alice wins if and only if (x + y) is odd. Instead of simulating games, we count pairs where x and y have different parity using the formula: odd_x × even_y + even_x × odd_y, achieving O(1) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Game Simulation (Brute Force)	O(n² × 2^(n+m))	O(n+m)	Simulate the game for each (x,y) pair using game theory recursion
Mathematical Pattern (Optimal)	O(1)	O(1)	Use parity rule: Alice wins when (x + y) is odd

Game Simulation (Brute Force) — Algorithm Steps

For each pair (x,y) where 1≤x≤n and 1≤y≤m
Use recursive function canWin(x,y,isAliceTurn) to simulate optimal play
Base case: if x=0 and y=0, current player loses (no moves available)
Try all possible moves: pick from lane 1 or lane 2
Current player wins if any move leads to opponent losing
Count configurations where Alice wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with (x,y) flowers and Alice's turn

Explore Moves

Try picking from lane 1 or lane 2

Recursive Calls

For each move, recursively check if opponent loses

Memoization

Cache results to avoid recalculating same states

Code -

solution.c — C

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

int canWin(int x, int y, int memo[][1001]) {
    if (x == 0 && y == 0) {
        return 0; // No moves left, current player loses
    }
    
    if (memo[x][y] != -1) {
        return memo[x][y];
    }
    
    // Try picking from lane 1
    if (x > 0 && !canWin(x - 1, y, memo)) {
        memo[x][y] = 1;
        return 1;
    }
    
    // Try picking from lane 2
    if (y > 0 && !canWin(x, y - 1, memo)) {
        memo[x][y] = 1;
        return 1;
    }
    
    memo[x][y] = 0;
    return 0;
}

int flowerGame(int n, int m) {
    int count = 0;
    for (int x = 1; x <= n; x++) {
        for (int y = 1; y <= m; y++) {
            int memo[1001][1001];
            for (int i = 0; i <= 1000; i++) {
                for (int j = 0; j <= 1000; j++) {
                    memo[i][j] = -1;
                }
            }
            if (canWin(x, y, memo)) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    printf("%d\n", flowerGame(n, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2^(n+m))

For each of n×m pairs, we simulate a game tree with exponential depth

⚠ Quadratic Growth

Space Complexity

O(n+m)

Recursion stack depth equals maximum flowers in both lanes

⚡ Linearithmic Space

Constraints

1 ≤ n, m ≤ 10⁵
Both n and m are positive integers
Time limit: 1 second per test case

42.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Game Simulation (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler