Maximum Number of Non-overlapping Palindrome Substrings - Problem

You are given a string s and a positive integer k.

Select a set of non-overlapping substrings from the string s that satisfy the following conditions:

The length of each substring is at least k.
Each substring is a palindrome.

Return the maximum number of substrings in an optimal selection.

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

Input & Output

Example 1 — Basic Case

$ Input: s = "abccba", k = 3

› Output: 1

💡 Note: We can select "bccb" (indices 1-4) or "abccba" (indices 0-5), both are palindromes of length ≥ 3. Maximum is 1.

Example 2 — Multiple Palindromes

$ Input: s = "ababa", k = 3

› Output: 1

💡 Note: We have palindromes "aba" (0-2) and "aba" (2-4), but they overlap at index 2. We can only select one of them. Maximum is 1.

Example 3 — No Valid Palindromes

$ Input: s = "abc", k = 4

› Output: 0

💡 Note: String length is 3, but we need palindromes of length ≥ 4. No valid palindromes exist.

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only
1 ≤ k ≤ s.length

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use a greedy approach: find all palindromic substrings of length ≥ k, then select non-overlapping ones by always choosing the earliest-ending palindrome. This maximizes the number of palindromes we can select. Best approach is Greedy with Time: O(n³), Space: O(n²).

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(n³ × 2^p) Space: O(n²)

Generate all possible palindromic substrings of length at least k, then use backtracking to find the maximum number of non-overlapping substrings we can select.

Dynamic Programming

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

Use dynamic programming where dp[i] represents the maximum number of palindromes we can select from substring s[0...i]. For each position, we either extend the previous result or start a new palindrome.

Greedy Approach

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

First find all palindromic substrings of length at least k. Sort them by ending position, then greedily select palindromes that don't overlap with previously selected ones.

Brute Force with Backtracking — Algorithm Steps

Find all palindromic substrings of length >= k
Use backtracking to try all combinations
Track maximum count of non-overlapping substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Palindromes

Identify all palindromic substrings of length >= k

Backtrack

Try all combinations of non-overlapping palindromes

Maximum Count

Return the maximum number found

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Palindrome;

bool isPalindrome(const char* s, int start, int end) {
    while (start < end) {
        if (s[start] != s[end]) {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

int backtrack(Palindrome* palindromes, int count, int index, int lastEnd, int current) {
    if (index == count) {
        return current;
    }
    
    // Skip current palindrome
    int result = backtrack(palindromes, count, index + 1, lastEnd, current);
    
    // Take current palindrome if it doesn't overlap
    if (palindromes[index].start > lastEnd) {
        int take = backtrack(palindromes, count, index + 1, palindromes[index].end, current + 1);
        result = result > take ? result : take;
    }
    
    return result;
}

int solution(const char* s, int k) {
    int n = strlen(s);
    Palindrome* palindromes = malloc(n * n * sizeof(Palindrome));
    int count = 0;
    
    // Find all palindromic substrings of length >= k
    for (int i = 0; i < n; i++) {
        for (int j = i + k - 1; j < n; j++) {
            if (isPalindrome(s, i, j)) {
                palindromes[count].start = i;
                palindromes[count].end = j;
                count++;
            }
        }
    }
    
    int result = backtrack(palindromes, count, 0, -1, 0);
    free(palindromes);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³ × 2^p)

O(n³) to find all palindromes, then 2^p combinations where p is number of palindromes

⚠ Quadratic Growth

Space Complexity

O(n²)

Store all palindromic substrings and recursion stack

⚠ Quadratic Space

68.0K Views

Medium Frequency

~25 min Avg. Time

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

Maximum Number of Non-overlapping Palindrome Substrings - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler