# Solving Leetcode Interviews in Seconds with AI: Valid Permutations for DI Sequence


	# 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](https://www.chatmagic.app), 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
	```python
	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
	```