Introduction

In this blog post, we will explore how to solve the LeetCode problem "903" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

You are given a string s of length n where s[i] is either: 'D' means decreasing, or 'I' means increasing. A permutation perm of n + 1 integers of all the integers in the range [0, n] is called a valid permutation if for all valid i: If s[i] == 'D', then perm[i] > perm[i + 1], and If s[i] == 'I', then perm[i] < perm[i + 1]. Return the number of valid permutations perm. Since the answer may be large, return it modulo 109 + 7. Example 1: Input: s = "DID" Output: 5 Explanation: The 5 valid permutations of (0, 1, 2, 3) are: (1, 0, 3, 2) (2, 0, 3, 1) (2, 1, 3, 0) (3, 0, 2, 1) (3, 1, 2, 0) Example 2: Input: s = "D" Output: 1 Constraints: n == s.length 1 <= n <= 200 s[i] is either 'I' or 'D'.

Explanation

Here's the solution:

• Dynamic Programming: The core idea is to use dynamic programming to build up the number of valid permutations incrementally. The DP state dp[i][j] represents the number of valid permutations for the first i characters of the string s, where the i-th number in the permutation is j.

• State Transition: We iterate through all possible values for the next number in the permutation and update the DP table based on whether the current character in the string s is 'I' (increasing) or 'D' (decreasing). The cumulative sum optimization significantly improves efficiency.

• Base Case: The base case is when we consider the first number in the permutation. We initialize the DP table accordingly.

• Time & Space Complexity: O(n^2), where n is the length of string s. Storage Complexity: O(n^2)

Code

    def numPermsDISequence(s: str) -> int:
    n = len(s)
    MOD = 10**9 + 7

    dp = [[0] * (n + 1) for _ in range(n + 1)]

    # Base case: For the first number, all values are possible
    for j in range(n + 1):
        dp[0][j] = 1

    # Iterate through the string
    for i in range(1, n + 1):
        new_dp = [0] * (n + 1)
        prefix_sum = 0

        # If s[i-1] == 'I', then perm[i-1] < perm[i]
        if s[i-1] == 'I':
            prefix_sum = 0
            for j in range(n + 1):
                new_dp[j] = prefix_sum
                prefix_sum = (prefix_sum + dp[i-1][j]) % MOD
        # If s[i-1] == 'D', then perm[i-1] > perm[i]
        else:
            prefix_sum = 0
            for j in range(n, -1, -1):
                new_dp[j-1] = prefix_sum
                prefix_sum = (prefix_sum + dp[i-1][j-1]) % MOD
        dp = new_dp

    result = 0
    for j in range(n+1):
        result = (result + dp[n][j]) % MOD

    return result