Alice and Bob Playing Flower Game

Alice and Bob Playing Flower Game - Problem

Math Medium

Alice and Bob are playing a turn-based game on a field with two lanes of flowers between them. There are x flowers in the first lane and y flowers in the second lane.

Game Rules:

Alice takes the first turn
In each turn, a player must choose one lane and pick exactly one flower from that lane
The player who removes the last flower (making both lanes empty) wins the game

Given two integers n and m, count the number of pairs (x, y) where:

Alice wins the game with optimal play
1 ≤ x ≤ n
1 ≤ y ≤ m

Input & Output

Example 1 — Small Grid

$ Input: n = 3, m = 2

› Output: 3

💡 Note: Alice wins for pairs: (1,2), (2,1), (3,2). These have odd sums: 3, 3, 5 respectively.

Example 2 — Symmetric Case

$ Input: n = 5, m = 4

› Output: 10

💡 Note: Odd numbers 1-5: {1,3,5} (3 values), Even numbers 1-4: {2,4} (2 values). Total: 3×2 + 2×2 = 10.

Example 3 — Minimum Case

$ Input: n = 1, m = 1

› Output: 0

💡 Note: Only pair (1,1) has sum 2 (even), so Bob wins. Alice wins in 0 cases.

Constraints

1 ≤ n, m ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is that Alice wins exactly when the total number of flowers (x+y) is odd, since she goes first. The optimal approach uses mathematical counting to calculate odd×even + even×odd combinations. Time: O(1), Space: O(1)

Common Approaches

✓ Mathematical Pattern

⏱️ Time: O(1) Space: O(1)

Analyze the game mathematically. Since Alice goes first, she wins exactly when the total number of flowers (x+y) is odd. This gives us a simple counting formula.

Simulate All Games

⏱️ Time: O(n×m×2^(n+m)) Space: O(n+m)

For each pair (x,y), recursively simulate the game with both players playing optimally. Use memoization to avoid recalculating the same game states.

Mathematical Pattern — Algorithm Steps

Recognize Alice wins when (x+y) is odd
Count pairs where x+y is odd
Use arithmetic: odd×even + even×odd

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze Pattern

Alice wins when (x+y) is odd

Count Combinations

odd×even + even×odd = winning pairs

Apply Formula

Calculate result instantly

Code -

solution.c — C

#include <stdio.h>

long long solution(int n, int m) {
    long long odd_n = (n + 1) / 2;
    long long even_n = n / 2;
    long long odd_m = (m + 1) / 2;
    long long even_m = m / 2;
    
    return odd_n * even_m + even_n * odd_m;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

Simple arithmetic calculation

✓ Linear Growth

Space Complexity

O(1)

Only using constant variables

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Pattern — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler