Valid Permutations for DI Sequence

Valid Permutations for DI Sequence - Problem

Valid Permutations for DI Sequence

You're given a string s of length n containing only two characters:

'D' means decreasing - the next number should be smaller
'I' means increasing - the next number should be larger

Your task is to find how many valid permutations of numbers [0, 1, 2, ..., n] can satisfy this sequence pattern.

A permutation perm is valid if:

When s[i] == 'D', then perm[i] > perm[i+1]
When s[i] == 'I', then perm[i] < perm[i+1]

For example, if s = "DI", we need a 3-number permutation where the first pair decreases and the second pair increases.

Goal: Return the count of valid permutations modulo 10⁹ + 7.

Input & Output

example_1.py — Basic DI sequence

$ Input: s = "DI"

› Output: 2

💡 Note: For sequence "DI" with numbers [0,1,2], we need first > second and second < third. Valid permutations are: [1,0,2] (1>0 ✓, 0<2 ✓) and [2,0,1] (2>0 ✓, 0<1 ✓). Total: 2 valid permutations.

example_2.py — Single character

$ Input: s = "D"

› Output: 1

💡 Note: For sequence "D" with numbers [0,1], we need first > second. Valid permutations: [1,0]. Only 1 valid permutation.

example_3.py — Increasing sequence

$ Input: s = "I"

› Output: 1

💡 Note: For sequence "I" with numbers [0,1], we need first < second. Valid permutations: [0,1]. Only 1 valid permutation.

Constraints

1 ≤ s.length ≤ 200
s[i] is either 'D' or 'I'
Result should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 15

The optimal approach uses dynamic programming with relative rankings. Instead of generating actual permutations, we track how many ways we can arrange numbers where each number has a specific rank among the elements placed so far. Key insight: only relative positions matter, not absolute values. Use prefix sums to optimize range queries, achieving O(n²) time complexity.

Common Approaches

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n²) Space: O(n²)

This approach uses dynamic programming where dp[i][j] represents the number of ways to place the first i+1 numbers such that the i-th number has rank j among those i+1 numbers. We use the key insight that we only need relative rankings, not absolute values.

Generate All Permutations

⏱️ Time: O((n+1)! * n) Space: O(n)

This approach generates all (n+1)! permutations of numbers [0,1,...,n] and checks each one against the DI sequence. While conceptually simple, it's extremely inefficient for larger inputs.

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp[0][0] = 1 (one way to place first number)
For each position i from 1 to n, and each possible rank j:
If s[i-1] == 'D': sum ways from ranks j to i-1 in previous position
If s[i-1] == 'I': sum ways from ranks 0 to j-1 in previous position
Use prefix sums to optimize the summation to O(1)
Return sum of dp[n][j] for all j from 0 to n

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0][0] = 1 (one way to place first element)

Process Each Position

For each character in sequence, update DP states

Apply Transitions

Use D/I rules to transfer counts between states

Sum Final States

Add up all ways to complete the sequence

Code -

solution.c — C

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

#define MOD 1000000007

int numPermsDISequence(char* s) {
    int n = strlen(s);
    
    // dp[i][j] = number of ways to arrange first i+1 numbers
    // where the i-th number has rank j among those i+1 numbers
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)calloc(i + 2, sizeof(long long));
    }
    dp[0][0] = 1;
    
    for (int i = 0; i < n; i++) {
        // Compute prefix sums for optimization
        long long* prefix = (long long*)calloc(i + 3, sizeof(long long));
        for (int k = 0; k <= i; k++) {
            prefix[k + 1] = (prefix[k] + dp[i][k]) % MOD;
        }
        
        for (int j = 0; j < i + 2; j++) {
            if (s[i] == 'D') {
                // Sum from rank j to i (inclusive)
                dp[i + 1][j] = (prefix[i + 1] - prefix[j] + MOD) % MOD;
            } else { // s[i] == 'I'
                // Sum from rank 0 to j-1 (inclusive)
                dp[i + 1][j] = prefix[j] % MOD;
            }
        }
        
        free(prefix);
    }
    
    long long result = 0;
    for (int j = 0; j <= n; j++) {
        result = (result + dp[n][j]) % MOD;
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return (int)result;
}

int main() {
    char s[20];
    scanf("%s", s);
    
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        for (int i = 1; i < len-1; i++) {
            s[i-1] = s[i];
        }
        s[len-2] = '\0';
    }
    
    printf("%d\n", numPermsDISequence(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: n positions × n possible ranks, with O(1) operations per cell using prefix sums

✓ Linear Growth

Space Complexity

O(n²)

DP table of size (n+1) × (n+1) to store intermediate results

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler