Flip Game II - Practice Coding Problems

Flip Game II - Problem

Math Dynamic Programming Backtracking Memoization Game Theory Medium

Welcome to the Flip Game II - a strategic two-player game that tests your ability to think ahead!

You and your friend are playing with a string currentState containing only '+' and '-' characters. On each turn, a player must flip two consecutive "++" into "--". The game continues until no more moves are possible.

The Challenge: Determine if the starting player (you) can guarantee a win with optimal play from both sides.

Rules:

Players take turns flipping consecutive "++" to "--"
The player who cannot make a move loses
Both players play optimally

Goal: Return true if you (the first player) can guarantee a win, false otherwise.

Example: For "+++", you can flip the first two to get "-++", then your opponent has no moves left - you win!

Input & Output

example_1.py — Basic Winning Case

$ Input: currentState = "++++"

› Output: true

💡 Note: The starting player can make moves like "--++" or "+--+" or "++--". Let's say they choose "--++", then the opponent can only make "----", and the game ends. The starting player made the last move, so they win.

example_2.py — Simple Losing Case

$ Input: currentState = "+"

› Output: false

💡 Note: The starting player cannot make any moves (no consecutive "++" found). Since they cannot move, they lose immediately.

example_3.py — Strategic Case

$ Input: currentState = "+++++"

› Output: true

💡 Note: Starting player can flip positions 1-2 to get "--+++". No matter what the opponent does next, the starting player can force a win through optimal play.

Visualization

Tap to expand

Understanding the Visualization

Identify Moves

Find all positions where we can flip '++' to '--'

Explore Outcomes

For each move, recursively analyze if opponent can win

Apply Game Theory

Current player wins if ANY move puts opponent in losing position

Cache Results

Memoize to avoid recomputing the same game states

Key Takeaway

🎯 Key Insight: In game theory problems, a position is winning if there exists at least one move that puts your opponent in a losing position. Use memoization to efficiently explore the game tree!

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

Same as memoized version but with constant factor improvements

⚠ Quadratic Growth

Space Complexity

O(2^n)

Hash table with optimized string storage

⚠ Quadratic Space

Constraints

1 ≤ currentState.length ≤ 60
currentState[i] is either '+' or '-'
Both players play optimally

Asked in

G Google 42 f Facebook 38 ⊞ Microsoft 25 a Amazon 15

The optimal solution uses memoized recursion with game theory principles. Key insight: a position is winning if ANY move leads to opponent's losing position. Use hash table to cache results and avoid recomputing same game states. Time complexity is O(n × 2^n) where n is string length.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Recursion with Hash Table	O(n * 2^n)	O(2^n)	Cache game states to avoid recomputing the same positions
Brute Force Recursion	O(n! * n)	O(n)	Try all possible moves recursively without memoization
Game Theory with Smart Memoization (Optimal)	O(n * 2^n)	O(2^n)	Optimized memoization with game theory insights for maximum efficiency

Memoized Recursion with Hash Table — Algorithm Steps

Use a hash map to store results of previously computed game states
Before recursing, check if current state result is already cached
If cached, return the stored result immediately
Otherwise, compute result recursively and cache it before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

First Computation

Compute result for a game state and store in cache

Cache Hit

When same state appears again, return cached result

Pruned Branches

Entire subtrees are avoided thanks to memoization

Efficiency Gain

Dramatic speedup compared to brute force

Code -

solution.c — C

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

#define MAX_STATES 10000

typedef struct {
    char state[1000];
    bool result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

bool getMemo(char* state) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].state, state) == 0) {
            return memo[i].result;
        }
    }
    return false; // Not found
}

bool hasMemo(char* state) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].state, state) == 0) {
            return true;
        }
    }
    return false;
}

void setMemo(char* state, bool result) {
    if (memoSize < MAX_STATES) {
        strcpy(memo[memoSize].state, state);
        memo[memoSize].result = result;
        memoSize++;
    }
}

bool canWinHelper(char* state) {
    if (hasMemo(state)) {
        return getMemo(state);
    }
    
    int len = strlen(state);
    // Try all possible moves
    for (int i = 0; i < len - 1; i++) {
        if (state[i] == '+' && state[i + 1] == '+') {
            // Make the move
            char* newState = malloc((len + 1) * sizeof(char));
            strcpy(newState, state);
            newState[i] = '-';
            newState[i + 1] = '-';
            // If opponent cannot win from this state, we win
            if (!canWinHelper(newState)) {
                setMemo(state, true);
                free(newState);
                return true;
            }
            free(newState);
        }
    }
    
    // If no winning move found, we lose
    setMemo(state, false);
    return false;
}

bool canWin(char* s) {
    memoSize = 0;
    return canWinHelper(s);
}

int main() {
    char state[1000];
    scanf("%s", state);
    // Remove quotes if present
    if (state[0] == '"') {
        int len = strlen(state);
        for (int i = 1; i < len - 1; i++) {
            state[i - 1] = state[i];
        }
        state[len - 2] = '\0';
    }
    
    printf("%s\n", canWin(state) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

At most 2^n possible game states, each taking O(n) time to process

⚠ Quadratic Growth

Space Complexity

O(2^n)

Hash table stores up to 2^n different game states

⚠ Quadratic Space

Constraints

1 ≤ currentState.length ≤ 60
currentState[i] is either '+' or '-'
Both players play optimally

28.4K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Memoized Recursion with Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler