Welcome to Subscribe On Youtube

2478. Number of Beautiful Partitions

Description

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 109 + 7.

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

 

Example 1:

Input: s = "23542185131", k = 3, minLength = 2
Output: 3
Explanation: There exists three ways to create a beautiful partition:
"2354 | 218 | 5131"
"2354 | 21851 | 31"
"2354218 | 51 | 31"

Example 2:

Input: s = "23542185131", k = 3, minLength = 3
Output: 1
Explanation: There exists one way to create a beautiful partition: "2354 | 218 | 5131".

Example 3:

Input: s = "3312958", k = 3, minLength = 1
Output: 1
Explanation: There exists one way to create a beautiful partition: "331 | 29 | 58".

 

Constraints:

  • 1 <= k, minLength <= s.length <= 1000
  • s consists of the digits '1' to '9'.

Solutions

  • class Solution {
        private static final int MOD = (int) 1e9 + 7;
    
        public int beautifulPartitions(String s, int k, int minLength) {
            int n = s.length();
            if (!prime(s.charAt(0)) || prime(s.charAt(n - 1))) {
                return 0;
            }
            int[][] f = new int[n + 1][k + 1];
            int[][] g = new int[n + 1][k + 1];
            f[0][0] = 1;
            g[0][0] = 1;
            for (int i = 1; i <= n; ++i) {
                if (i >= minLength && !prime(s.charAt(i - 1)) && (i == n || prime(s.charAt(i)))) {
                    for (int j = 1; j <= k; ++j) {
                        f[i][j] = g[i - minLength][j - 1];
                    }
                }
                for (int j = 0; j <= k; ++j) {
                    g[i][j] = (g[i - 1][j] + f[i][j]) % MOD;
                }
            }
            return f[n][k];
        }
    
        private boolean prime(char c) {
            return c == '2' || c == '3' || c == '5' || c == '7';
        }
    }
    
  • class Solution {
    public:
        const int mod = 1e9 + 7;
    
        int beautifulPartitions(string s, int k, int minLength) {
            int n = s.size();
            auto prime = [](char c) {
                return c == '2' || c == '3' || c == '5' || c == '7';
            };
            if (!prime(s[0]) || prime(s[n - 1])) return 0;
            vector<vector<int>> f(n + 1, vector<int>(k + 1));
            vector<vector<int>> g(n + 1, vector<int>(k + 1));
            f[0][0] = g[0][0] = 1;
            for (int i = 1; i <= n; ++i) {
                if (i >= minLength && !prime(s[i - 1]) && (i == n || prime(s[i]))) {
                    for (int j = 1; j <= k; ++j) {
                        f[i][j] = g[i - minLength][j - 1];
                    }
                }
                for (int j = 0; j <= k; ++j) {
                    g[i][j] = (g[i - 1][j] + f[i][j]) % mod;
                }
            }
            return f[n][k];
        }
    };
    
  • class Solution:
        def beautifulPartitions(self, s: str, k: int, minLength: int) -> int:
            primes = '2357'
            if s[0] not in primes or s[-1] in primes:
                return 0
            mod = 10**9 + 7
            n = len(s)
            f = [[0] * (k + 1) for _ in range(n + 1)]
            g = [[0] * (k + 1) for _ in range(n + 1)]
            f[0][0] = g[0][0] = 1
            for i, c in enumerate(s, 1):
                if i >= minLength and c not in primes and (i == n or s[i] in primes):
                    for j in range(1, k + 1):
                        f[i][j] = g[i - minLength][j - 1]
                for j in range(k + 1):
                    g[i][j] = (g[i - 1][j] + f[i][j]) % mod
            return f[n][k]
    
    
  • func beautifulPartitions(s string, k int, minLength int) int {
    	prime := func(c byte) bool {
    		return c == '2' || c == '3' || c == '5' || c == '7'
    	}
    	n := len(s)
    	if !prime(s[0]) || prime(s[n-1]) {
    		return 0
    	}
    	const mod int = 1e9 + 7
    	f := make([][]int, n+1)
    	g := make([][]int, n+1)
    	for i := range f {
    		f[i] = make([]int, k+1)
    		g[i] = make([]int, k+1)
    	}
    	f[0][0], g[0][0] = 1, 1
    	for i := 1; i <= n; i++ {
    		if i >= minLength && !prime(s[i-1]) && (i == n || prime(s[i])) {
    			for j := 1; j <= k; j++ {
    				f[i][j] = g[i-minLength][j-1]
    			}
    		}
    		for j := 0; j <= k; j++ {
    			g[i][j] = (g[i-1][j] + f[i][j]) % mod
    		}
    	}
    	return f[n][k]
    }
    

All Problems

All Solutions