Count The Number of Winning Sequences - Practice Coding Problems

Count The Number of Winning Sequences - Problem

In this fantasy battle game, Alice and Bob face off in n rounds of magical creature summoning! Each round, they simultaneously choose one of three powerful creatures:

🔥 Fire Dragon ('F') - Burns Earth Golems to ash
🌊 Water Serpent ('W') - Extinguishes Fire Dragons
🌍 Earth Golem ('E') - Absorbs Water Serpents

The rock-paper-scissors style scoring works as follows:

Fire Dragon beats Earth Golem (Fire burns Earth)
Water Serpent beats Fire Dragon (Water extinguishes Fire)
Earth Golem beats Water Serpent (Earth absorbs Water)
Same creatures = No points for either player

You know Alice's complete strategy as a string s of length n, but Bob's moves are unknown. However, Bob has one constraint: he never summons the same creature twice in a row.

Goal: Count how many different sequences Bob can play to strictly beat Alice (score more points than her). Return the answer modulo 10^9 + 7.

Input & Output

example_1.py — Basic Example

$ Input: s = "FFF"

› Output: 3

💡 Note: Alice plays F-F-F. Bob can win with: WWW (+3), WWE (+1), WEW (+1). Bob cannot repeat creatures consecutively, so these are the only winning sequences.

example_2.py — Mixed Strategy

$ Input: s = "FWEFW"

› Output: 18

💡 Note: Alice plays a mixed strategy. Bob has multiple ways to counter each move while respecting the no-consecutive-same-creature constraint.

example_3.py — Single Round

$ Input: s = "E"

› Output: 1

💡 Note: Alice plays Earth Golem. Bob can only win by playing Water Serpent (W), since E beats W is false, but W beats F and F beats E, so W vs E gives 0 points. Actually, Bob wins with F (Fire beats Earth).

Visualization

Tap to expand

Understanding the Visualization

Know the Rules

Fire beats Earth, Water beats Fire, Earth beats Water (like rock-paper-scissors)

Constraint

Bob cannot summon the same creature twice in a row

Dynamic Programming

Track all possible game states: (round, last_creature, score_difference)

Count Winners

Sum up all paths where Bob's final score > Alice's score

Key Takeaway

🎯 Key Insight: Use dynamic programming to track game states (round, last_creature, score_difference) with memoization, avoiding the exponential time complexity of brute force while systematically counting all winning sequences for Bob.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

n rounds × 3 creatures × O(n) possible score differences, with memoization preventing recalculation

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table storing results for all possible states

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of characters 'F', 'W', and 'E'
Bob never summons the same creature in consecutive rounds
Answer fits in 32-bit integer when taken modulo 10⁹ + 7

Asked in

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

The optimal solution uses dynamic programming with memoization to track game states efficiently. Each state consists of the current round, Bob's last creature, and the score difference. This approach has O(n²) time complexity and can handle the maximum constraint of n=1000, unlike the brute force O(3ⁿ) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use memoized recursion to track game states efficiently
Brute Force (Generate All Sequences)	O(3^n)	O(n)	Generate all valid Bob sequences and count winning ones

Dynamic Programming (Optimal) — Algorithm Steps

Define state as (round, last_creature, score_difference)
Use memoization to cache results for each state
For each round, try all valid creatures Bob can play
Calculate new score difference and recurse to next round
Base case: if score_difference > 0 at end, Bob wins

Visualization

Tap to expand

Step-by-Step Walkthrough

Define State

State = (round, last_creature, score_difference)

Memoization

Cache results to avoid recalculating same states

State Transitions

From each state, try all valid creature choices

Combine Results

Sum up all paths that lead to Bob winning

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 1000

typedef struct {
    int round, last, score;
    int result;
} MemoEntry;

MemoEntry memo[MAXN * 3 * (2*MAXN + 1)];
int memoSize = 0;

int beats(char a, char b) {
    if (a == b) return 0;
    if ((a == 'F' && b == 'E') || (a == 'W' && b == 'F') || (a == 'E' && b == 'W')) {
        return 1;
    }
    return -1;
}

int findMemo(int round, int last, int score) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].round == round && memo[i].last == last && memo[i].score == score) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int round, int last, int score, int result) {
    memo[memoSize].round = round;
    memo[memoSize].last = last;
    memo[memoSize].score = score;
    memo[memoSize].result = result;
    memoSize++;
}

int dp(char* s, int n, int roundIdx, int lastCreature, int scoreDiff) {
    if (roundIdx == n) {
        return scoreDiff > 0 ? 1 : 0;
    }
    
    int cached = findMemo(roundIdx, lastCreature, scoreDiff);
    if (cached != -1) {
        return cached;
    }
    
    char creatures[] = {'F', 'W', 'E'};
    long long result = 0;
    
    for (int i = 0; i < 3; i++) {
        if (lastCreature == -1 || i != lastCreature) {
            int newScore = scoreDiff + beats(creatures[i], s[roundIdx]);
            result = (result + dp(s, n, roundIdx + 1, i, newScore)) % MOD;
        }
    }
    
    addMemo(roundIdx, lastCreature, scoreDiff, result);
    return result;
}

int countWinningSequences(char* s) {
    int n = strlen(s);
    memoSize = 0;
    return dp(s, n, 0, -1, 0);
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        len = strlen(s);
        if (s[len-1] == '"') s[len-1] = '\0';
    }
    
    printf("%d\n", countWinningSequences(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

n rounds × 3 creatures × O(n) possible score differences, with memoization preventing recalculation

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table storing results for all possible states

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of characters 'F', 'W', and 'E'
Bob never summons the same creature in consecutive rounds
Answer fits in 32-bit integer when taken modulo 10⁹ + 7

43.7K Views

Medium-High Frequency

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler