Count The Number of Winning Sequences - Problem

Alice and Bob are playing a fantasy battle game consisting of n rounds where they summon one of three magical creatures each round: a Fire Dragon, a Water Serpent, or an Earth Golem.

In each round, players simultaneously summon their creature and are awarded points as follows:

If one player summons a Fire Dragon and the other summons an Earth Golem, the player who summoned the Fire Dragon is awarded a point.
If one player summons a Water Serpent and the other summons a Fire Dragon, the player who summoned the Water Serpent is awarded a point.
If one player summons an Earth Golem and the other summons a Water Serpent, the player who summoned the Earth Golem is awarded a point.
If both players summon the same creature, no player is awarded a point.

You are given a string s consisting of n characters 'F', 'W', and 'E', representing the sequence of creatures Alice will summon in each round.

Bob's sequence of moves is unknown, but it is guaranteed that Bob will never summon the same creature in two consecutive rounds. Bob beats Alice if the total number of points awarded to Bob after n rounds is strictly greater than the points awarded to Alice.

Return the number of distinct sequences Bob can use to beat Alice. Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: s = "FW"

› Output: 1

💡 Note: For Alice's sequence FW, Bob can win with sequence WE: (W vs F: Bob+1), (E vs W: Bob+1), final score 2-0.

Example 2 — Single Round

$ Input: s = "F"

› Output: 1

💡 Note: Bob can win only by playing W (Water beats Fire), giving him 1 point vs Alice's 0.

Example 3 — All Same

$ Input: s = "FFF"

› Output: 2

💡 Note: Bob must avoid consecutive moves. He can play WEW (scores +1,0,+1 = +2) or EWE (scores 0,+1,0 = +1), both beat Alice's 0.

Constraints

1 ≤ s.length ≤ 1000
s consists only of 'F', 'W', and 'E'

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18

The key insight is to use dynamic programming to track all possible game states defined by (position, last_move, score_difference). The memoized approach efficiently counts winning sequences by avoiding redundant calculations. Time: O(n × 3 × 2n), Space: O(n × 3 × 2n)

Common Approaches

✓ Brute Force Recursion

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

Try all possible creature combinations for Bob while ensuring no consecutive duplicates. For each complete sequence, calculate the final score and check if Bob wins.

Memoized Dynamic Programming

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

Transform the brute force approach by caching results for each state (position, last_move, score_difference). This eliminates redundant calculations when the same state is reached through different paths.

Optimized 2D Dynamic Programming

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

Instead of tracking absolute scores, track only the score difference (Bob's score - Alice's score). Use a 2D DP table where dp[i][j][diff] represents the number of ways at position i with last move j and score difference diff.

Brute Force Recursion — Algorithm Steps

Generate all valid Bob sequences recursively
For each sequence, simulate the game and calculate scores
Count sequences where Bob's score > Alice's score

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Sequences

Try all possible Bob moves avoiding consecutive repeats

Calculate Scores

For each sequence, simulate the game and count points

Count Winners

Count sequences where Bob score > Alice score

Code -

solution.c — C

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

const int MOD = 1000000007;

int getPoints(char aliceMove, char bobMove) {
    if (aliceMove == bobMove) return 0;
    if ((bobMove == 'F' && aliceMove == 'E') ||
        (bobMove == 'W' && aliceMove == 'F') ||
        (bobMove == 'E' && aliceMove == 'W')) {
        return 1; // Bob gets point
    }
    return -1; // Alice gets point
}

int backtrack(const char* s, int pos, char lastMove, int bobScore, int aliceScore, int n) {
    if (pos == n) {
        return bobScore > aliceScore ? 1 : 0;
    }
    
    int count = 0;
    char moves[] = {'F', 'W', 'E'};
    
    for (int i = 0; i < 3; i++) {
        char move = moves[i];
        if (pos == 0 || move != lastMove) {
            int points = getPoints(s[pos], move);
            if (points == 1) {
                count = (count + backtrack(s, pos + 1, move, bobScore + 1, aliceScore, n)) % MOD;
            } else if (points == -1) {
                count = (count + backtrack(s, pos + 1, move, bobScore, aliceScore + 1, n)) % MOD;
            } else {
                count = (count + backtrack(s, pos + 1, move, bobScore, aliceScore, n)) % MOD;
            }
        }
    }
    
    return count;
}

int solution(const char* s) {
    int n = strlen(s);
    return backtrack(s, 0, ' ', 0, 0, n);
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each position, we try 2 creatures (avoiding consecutive), leading to exponential possibilities

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is n levels deep

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

428 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

Count The Number of Winning Sequences - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler