Maximum Number of Non-overlapping Palindrome Substrings

Maximum Number of Non-overlapping Palindrome Substrings - Problem

Imagine you're a text editor designer creating an advanced palindrome highlighting feature. Given a string s and a minimum length k, your goal is to select the maximum number of non-overlapping substrings where:

Each substring has at least k characters
Each substring is a palindrome (reads the same forwards and backwards)
No two selected substrings overlap

For example, with s = "abacabad" and k = 3, you could select "aba" at position 0-2 and "aba" at position 4-6, giving you 2 palindromic substrings.

Return the maximum number of palindromic substrings you can select following these rules.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can select "aba" (positions 0-2) and "aba" (positions 4-6). Both are palindromes with length ≥ 3 and don't overlap.

example_2.py — Single Long Palindrome

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

› Output: 1

💡 Note: The entire string "abccba" is a palindrome of length 6 ≥ 3. We can only select one non-overlapping substring.

example_3.py — No Valid Palindromes

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

› Output: 0

💡 Note: There are no palindromic substrings of length ≥ 3 in this string, so we return 0.

Constraints

1 ≤ s.length ≤ 2000
1 ≤ k ≤ s.length
s consists only of lowercase English letters
k represents the minimum required length for each palindromic substring

Visualization

Tap to expand

Understanding the Visualization

Survey the Land

Scan from left to right looking for valid palindromic territories of size ≥ k

Claim First Territory

When you find a valid palindrome, immediately claim it to maximize future opportunities

Continue Exploration

Move past the claimed territory and repeat the process

Count Your Claims

The total number of claimed territories is your answer

Key Takeaway

🎯 Key Insight: The greedy approach works because claiming the leftmost valid palindrome never blocks us from finding an optimal solution. It's like claiming the best available territory first - this maximizes our opportunities for future claims!

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal approach uses a greedy algorithm that scans left to right, selecting the earliest valid palindrome at each step. This works because taking the leftmost palindrome never prevents finding an optimal solution - it maximizes future opportunities. The algorithm runs in O(n²) time with O(1) space, making it the most efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Algorithm (Most Efficient)	O(n²)	O(1)	Greedily select the earliest valid palindromes for optimal result
Dynamic Programming (Optimal)	O(n²)	O(n²)	Use dynamic programming to find optimal selection efficiently
Brute Force (Try All Combinations)	O(2^n)	O(n²)	Generate all possible combinations of non-overlapping palindromic substrings

Greedy Algorithm (Most Efficient) — Algorithm Steps

Scan string from left to right
For each position, check if we can form a palindrome of length >= k
When we find a valid palindrome, immediately select it
Skip to the end of selected palindrome and continue
Return the total count of selected palindromes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Left

Begin scanning from the leftmost position

Find First Palindrome

Select the first valid palindrome found

Skip and Continue

Move past selected palindrome and repeat

Code -

solution.c — C

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

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

int maxPalindromes(char* s, int k) {
    int n = strlen(s);
    int count = 0;
    int i = 0;
    
    while (i < n) {
        // Try to find palindrome starting at current position
        bool found = false;
        
        // Check all possible lengths >= k starting from position i
        for (int j = i + k; j <= n; j++) {
            if (isPalindrome(s, i, j - 1)) {
                count++;
                i = j; // Move to end of current palindrome
                found = true;
                break;
            }
        }
        
        if (!found) {
            i++;
        }
    }
    
    return count;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, " ");
    char* s = token;
    if (s[0] == '"') s++;
    if (s[strlen(s)-1] == '"') s[strlen(s)-1] = '\0';
    
    token = strtok(NULL, " ");
    int k = atoi(token);
    
    printf("%d\n", maxPalindromes(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, we check all possible palindromes starting there

⚠ Quadratic Growth

Space Complexity

O(1)

Only constant extra space needed

✓ Linear Space

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

Greedy Algorithm (Most Efficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler