Flip Game II

Flip Game II - Problem

Math Dynamic Programming Backtracking Memoization Game Theory Medium

You are playing a Flip Game with your friend. You are given a string currentState that contains only '+' and '-'. You and your friend take turns to flip two consecutive "++" into "--".

The game ends when a person can no longer make a move, and therefore the other person will be the winner.

Return true if the starting player can guarantee a win, and false otherwise.

Input & Output

Example 1 — Basic Winning Case

$ Input: currentState = "++++"

› Output: true

💡 Note: Player 1 can flip the first two ++ to get "--++", then no matter what player 2 does, player 1 can win on the next turn.

Example 2 — No Winning Move

$ Input: currentState = "+"

› Output: false

💡 Note: Player 1 cannot make any move since there are no consecutive ++ pairs, so player 1 loses immediately.

Example 3 — Complex Case

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

› Output: true

💡 Note: Player 1 has two possible moves: flip first ++ or last ++. At least one of these moves leads to a winning strategy.

Constraints

1 ≤ currentState.length ≤ 20
currentState[i] is either '+' or '-'

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8 a Amazon 6

The key insight is to use game theory: a position is winning if there exists at least one move that leads to a losing position for the opponent. The memoized recursion approach is optimal, avoiding redundant calculations by caching results. Time: O(n × 2^n), Space: O(2^n).

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force Recursion

⏱️ Time: O(2^n) Space: O(n)

For each possible move (flipping "++" to "--"), recursively check if the opponent can win from the resulting state. If any move leads to the opponent losing, current player wins.

Memoized Recursion

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

Same recursive approach as brute force, but store results of each game state in a hash map. When we encounter the same state again, return the cached result instead of recomputing.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int solution(int* nums, int numsSize) {
    // Group numbers by remainder when divided by 3
    int groups[3][1000];
    int groupSizes[3] = {0, 0, 0};
    
    for (int i = 0; i < numsSize; i++) {
        int remainder = nums[i] % 3;
        if (remainder < 0) remainder += 3;
        groups[remainder][groupSizes[remainder]++] = nums[i];
    }
    
    // Sort each group in descending order
    for (int i = 0; i < 3; i++) {
        qsort(groups[i], groupSizes[i], sizeof(int), compare);
    }
    
    // Sum all numbers with remainder 0
    int result = 0;
    for (int i = 0; i < groupSizes[0]; i++) {
        result += groups[0][i];
    }
    
    // For remainder 1 and 2, take pairs
    int minPairs = groupSizes[1] < groupSizes[2] ? groupSizes[1] : groupSizes[2];
    for (int i = 0; i < minPairs; i++) {
        result += groups[1][i] + groups[2][i];
    }
    
    // Take multiples of 3 from remaining groups
    for (int i = minPairs; i + 2 < groupSizes[1]; i += 3) {
        result += groups[1][i] + groups[1][i + 1] + groups[1][i + 2];
    }
    
    for (int i = minPairs; i + 2 < groupSizes[2]; i += 3) {
        result += groups[2][i] + groups[2][i + 1] + groups[2][i + 2];
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int count = 0;
    char* ptr = line + 1; // Skip '['
    
    while (*ptr != ']' && *ptr != '\0') {
        if ((*ptr >= '0' && *ptr <= '9') || *ptr == '-') {
            nums[count++] = atoi(ptr);
            while (*ptr != ',' && *ptr != ']' && *ptr != '\0') ptr++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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