Skip to content

3320. Count The Number of Winning Sequences 👍

  • Time: $O(3n^2) = O(n^2)$
  • Space: $O(3n^2) = O(n^2)$
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class Solution {
 public:
  int countWinningSequences(string s) {
    vector<vector<vector<int>>> mem(
        s.length(), vector<vector<int>>(3, vector<int>(2 * s.length(), -1)));
    const long ans = count(s, 0, 0, 0, mem) + count(s, 0, 1, 0, mem) +
                     count(s, 0, 2, 0, mem);
    return (ans / 2) % kMod;
  }

 private:
  static constexpr int kMod = 1'000'000'007;

  // Returns the number of distinct sequences Bob can use to beat Alice for
  // s[i..n), where the previous character is `prev` (0: F, 1: W, 2: E) and the
  // number of points that Bob is having is `bob`.
  long count(const string& s, int i, int prev, int bob,
             vector<vector<vector<int>>>& mem) {
    if (i == s.length())
      return bob > 0 ? 1 : 0;
    // Map [-s.length(), s.length() - 1] to [0, 2 * s.length() - 1].
    int& res = mem[i][prev][bob + s.length()];
    if (res != -1)
      return res;

    long f = 0;  // If Bob summons a Fire Dragon at i.
    long w = 0;  // If Bob summons a Water Serpent at i.
    long e = 0;  // If Bob summons a Earth Golem at i.

    switch (s[i]) {
      case 'F':
        if (prev != 0)
          f = count(s, i + 1, 0, bob, mem) % kMod;
        if (prev != 1)
          w = count(s, i + 1, 1, bob + 1, mem) % kMod;
        if (prev != 2)
          e = count(s, i + 1, 2, bob - 1, mem) % kMod;
        break;
      case 'W':
        if (prev != 0)
          f = count(s, i + 1, 0, bob - 1, mem) % kMod;
        if (prev != 1)
          w = count(s, i + 1, 1, bob, mem) % kMod;
        if (prev != 2)
          e = count(s, i + 1, 2, bob + 1, mem) % kMod;
        break;
      case 'E':
        if (prev != 0)
          f = count(s, i + 1, 0, bob + 1, mem) % kMod;
        if (prev != 1)
          w = count(s, i + 1, 1, bob - 1, mem) % kMod;
        if (prev != 2)
          e = count(s, i + 1, 2, bob, mem) % kMod;
      default:
        break;
    }

    return res = f + w + e;
  }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Solution {
  public int countWinningSequences(String s) {
    Long[][][] mem = new Long[s.length()][3][2 * s.length()];
    final long ans = count(s, 0, 0, 0, mem) + count(s, 0, 1, 0, mem) + count(s, 0, 2, 0, mem);
    return (int) ((ans / 2) % MOD);
  }

  private static final int MOD = 1_000_000_007;

  // Returns the number of distinct sequences Bob can use to beat Alice for
  // s[i..n), where the previous character is `prev` (0: F, 1: W, 2: E) and the
  // number of points that Bob is having is `bob`.
  private long count(final String s, int i, int prev, int bob, Long[][][] mem) {
    if (i == s.length())
      return bob > 0 ? 1 : 0;
    final int bobIdx = bob + s.length();
    if (mem[i][prev][bobIdx] != null)
      return mem[i][prev][bobIdx];

    long f = 0; // If Bob summons a Fire Dragon at i.
    long w = 0; // If Bob summons a Water Serpent at i.
    long e = 0; // If Bob summons a Earth Golem at i.

    switch (s.charAt(i)) {
      case 'F':
        if (prev != 0)
          f = count(s, i + 1, 0, bob, mem) % MOD;
        if (prev != 1)
          w = count(s, i + 1, 1, bob + 1, mem) % MOD;
        if (prev != 2)
          e = count(s, i + 1, 2, bob - 1, mem) % MOD;
        break;
      case 'W':
        if (prev != 0)
          f = count(s, i + 1, 0, bob - 1, mem) % MOD;
        if (prev != 1)
          w = count(s, i + 1, 1, bob, mem) % MOD;
        if (prev != 2)
          e = count(s, i + 1, 2, bob + 1, mem) % MOD;
        break;
      case 'E':
        if (prev != 0)
          f = count(s, i + 1, 0, bob + 1, mem) % MOD;
        if (prev != 1)
          w = count(s, i + 1, 1, bob - 1, mem) % MOD;
        if (prev != 2)
          e = count(s, i + 1, 2, bob, mem) % MOD;
        break;
      default:
        break;
    }

    return mem[i][prev][bobIdx] = f + w + e;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Solution:
  def countWinningSequences(self, s: str) -> int:
    MOD = 1_000_000_007

    @functools.lru_cache(None)
    def dp(i: int, prev: int, bob: int) -> int:
      """
      Returns the number of distinct sequences Bob can use to beat Alice for
      s[i..n), where the previous character is `prev` (0: F, 1: W, 2: E) and the
      number of points that Bob is having is `bob`.
      """
      if i == len(s):
        return int(bob > 0)

      f = 0  # If Bob summons a Fire Dragon at i.
      w = 0  # If Bob summons a Water Serpent at i.
      e = 0  # If Bob summons a Earth Golem at i.

      match s[i]:
        case 'F':
          if prev != 0:
            f = dp(i + 1, 0, bob) % MOD
          if prev != 1:
            w = dp(i + 1, 1, bob + 1) % MOD
          if prev != 2:
            e = dp(i + 1, 2, bob - 1) % MOD
        case 'W':
          if prev != 0:
            f = dp(i + 1, 0, bob - 1) % MOD
          if prev != 1:
            w = dp(i + 1, 1, bob) % MOD
          if prev != 2:
            e = dp(i + 1, 2, bob + 1) % MOD
        case 'E':
          if prev != 0:
            f = dp(i + 1, 0, bob + 1) % MOD
          if prev != 1:
            w = dp(i + 1, 1, bob - 1) % MOD
          if prev != 2:
            e = dp(i + 1, 2, bob) % MOD

      return f + w + e

    return (dp(0, 0, 0) + dp(0, 1, 0) + dp(0, 2, 0)) // 2 % MOD