Number of Beautiful Partitions - Problem

You are given a string s that consists of the digits '1' to '9' and two integers k and minLength.

A partition of s is called beautiful if:

s is partitioned into k non-intersecting substrings.
Each substring has a length of at least minLength.
Each substring starts with a prime digit and ends with a non-prime digit. Prime digits are '2', '3', '5', and '7', and the rest of the digits are non-prime.

Return the number of beautiful partitions of s. Since the answer may be very large, return it modulo 10⁹ + 7.

A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

$ Input: s = "23331", k = 2, minLength = 1

› Output: 1

💡 Note: Only one beautiful partition: ["233", "31"]. "233" starts with prime '2' and ends with non-prime '3'. "31" starts with prime '3' and ends with non-prime '1'.

Example 2 — No Valid Partition

$ Input: s = "23", k = 3, minLength = 1

› Output: 0

💡 Note: Cannot partition string of length 2 into 3 parts, so answer is 0.

Example 3 — Multiple Ways

$ Input: s = "3213", k = 2, minLength = 1

› Output: 0

💡 Note: No beautiful partitions exist. For any 2-part partition, we cannot satisfy both parts starting with prime and ending with non-prime digits. For example, ["321", "3"] has "321" valid (starts with '3', ends with '1'), but "3" is invalid (starts and ends with prime '3').

Constraints

1 ≤ k ≤ min(s.length, 100)
1 ≤ minLength ≤ s.length
1 ≤ s.length ≤ 1000
s consists of digits '1' through '9'

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is to use dynamic programming to count valid partitions systematically. We define states as (position, remaining_partitions) and build the solution by trying all valid cuts. Best approach uses memoization with O(n²k) time and O(nk) space complexity.

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents number of ways to partition s[0...i-1] into j parts. Fill table bottom-up by considering all valid previous positions.

Brute Force Recursion

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

Generate all possible partitions by trying every valid cut position and recursively solving for remaining string. Check if each partition satisfies the prime/non-prime constraints.

Dynamic Programming with Memoization

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

Use memoization to store results of (position, remaining_partitions) states. This eliminates redundant calculations and reduces time complexity significantly.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create DP table dp[i][j] for i positions and j partitions
Step 2: Initialize base cases
Step 3: Fill table using transitions from valid previous states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base case dp[0][0] = 1

Fill Table

For each position and partition count, calculate ways

Result

Answer is in dp[n][k]

Code -

solution.c — C

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

const int MOD = 1000000007;

int isPrime(char c) {
    return c == '2' || c == '3' || c == '5' || c == '7';
}

int isNonPrime(char c) {
    return c == '1' || c == '4' || c == '6' || c == '8' || c == '9';
}

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(char* s, int k, int minLength) {
    int n = strlen(s);
    
    // dp[i][j] = number of ways to partition s[0:i] into j parts
    long long dp[1001][101];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1;
    
    for (int i = 1; i <= n; i++) {
        // Copy previous state
        for (int j = 0; j <= k; j++) {
            dp[i][j] = dp[i-1][j];
        }
        
        // Try making a partition ending at i-1
        if (isNonPrime(s[i-1])) {
            for (int j = 1; j <= k; j++) {
                // Look for valid start positions
                for (int start = max(0, i - n); start <= i - minLength; start++) {
                    if (start >= 0 && isPrime(s[start])) {
                        dp[i][j] = (dp[i][j] + dp[start][j-1]) % MOD;
                    }
                }
            }
        }
    }
    
    return (int)dp[n][k];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Three nested loops: n positions × k partitions × n possible previous positions

⚠ Quadratic Growth

Space Complexity

O(n × k)

2D DP table stores values for n positions and k partitions

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 min Avg. Time

847 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

Number of Beautiful Partitions - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler