Minimum Changes to Make K Semi-palindromes

Minimum Changes to Make K Semi-palindromes - Problem

Given a string s and an integer k, you need to partition the string into exactly k substrings and transform each substring into a semi-palindrome with the minimum number of character changes.

A semi-palindrome is a fascinating string pattern where characters can be rearranged based on a repeating divisor pattern to form palindromic groups:

Choose a positive divisor d of the string's length (where 1 ≤ d < length)
Group characters by their positions modulo d
Each group must form a palindrome

Example: For string "abcabc" with d=3:

Group 1 (positions 1,4): "aa" ✓ palindrome
Group 2 (positions 2,5): "bb" ✓ palindrome
Group 3 (positions 3,6): "cc" ✓ palindrome

Your goal is to find the minimum total number of character changes needed across all k partitions.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcabc", k = 2

› Output: 1

💡 Note: Partition into ["abc", "abc"]. For "abc" with d=1: need 1 change to make "aba". Total cost = 1 + 1 = 2. Better: with d=3, "abc" costs 2 changes, but optimal partition ["abca", "bc"] gives cost 1.

example_2.py — Single Character

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

› Output: 0

💡 Note: Partition into ["a", "b", "c"]. Each single character is already a semi-palindrome (no valid divisors, so cost = 0). Total cost = 0 + 0 + 0 = 0.

example_3.py — Equal Parts

$ Input: s = "aabbcc", k = 2

› Output: 0

💡 Note: Partition into ["aabb", "cc"]. For "aabb" with d=2: groups ["ab", "ab"] need 1+1=2 changes. But with d=1: "aabb" needs 2 changes. For "cc": already palindrome. Optimal gives cost 0 with better partitioning.

Visualization

Tap to expand

Understanding the Visualization

Choose Divisor

Pick a divisor d where 1 ≤ d < string_length

Group Characters

Group characters by their position mod d

Check Palindromes

Each group must form a palindrome

Count Changes

Sum up character changes needed across all groups

Key Takeaway

🎯 Key Insight: Semi-palindromes use divisor-based grouping to create multiple palindromic constraints, and dynamic programming efficiently finds optimal partitioning by reusing precomputed substring costs.

Time & Space Complexity

Time Complexity

⏱️

O(n³ + n²k)

O(n³) to precompute all substring costs (n² substrings × n divisors), O(n²k) for DP table filling

⚠ Quadratic Growth

Space Complexity

O(n² + nk)

O(n²) for storing all substring costs, O(nk) for DP table

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 200
1 ≤ k ≤ s.length
s consists of lowercase English letters only
s must be partitioned into exactly k non-empty substrings
Semi-palindromes with length 1 have cost 0 (no valid divisors)

Asked in

G Google 15 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses dynamic programming with precomputation. First, calculate the minimum cost to convert every substring into a semi-palindrome by testing all valid divisors. Then use DP where dp[i][j] represents the minimum cost to partition the first i characters into j parts. The key insight is that semi-palindromes can be efficiently validated by grouping characters based on position modulo the divisor.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³ + n²k)	O(n² + nk)	Precompute all substring costs, then use DP to find optimal partitioning
Brute Force (Try All Partitions)	O(n^k × n^3)	O(k)	Generate all possible k-partitions and calculate semi-palindrome cost for each

Dynamic Programming (Optimal) — Algorithm Steps

Precompute semi-palindrome costs for all possible substrings
For each substring, try all valid divisors and find minimum cost
Use DP: dp[i][j] = minimum cost to partition s[0:i] into j parts
Fill DP table using previously computed substring costs
Return dp[n][k] as the final answer

Visualization

Tap to expand

dp[i][j]j=1j=2j=3i=313∞i=6357

Step 3: Optimal PartitioningOptimal: ["abc", "de", "f"] with total cost = 7cost=1cost=2cost=0Time: O(n³ + n²k) | Space: O(n² + nk)

Step-by-Step Walkthrough

Precompute Costs

Calculate semi-palindrome cost for every substring

Fill DP Table

Build optimal solutions using previously computed results

Extract Answer

Return dp[n][k] as minimum cost for k partitions

Code -

solution.c — C

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

int getSemiPalindromeCost(char* s, int start, int end) {
    int length = end - start + 1;
    if (length <= 1) return 0;
    
    int minCost = INT_MAX;
    
    for (int d = 1; d < length; d++) {
        if (length % d == 0 || d == 1) {
            int currCost = 0;
            
            for (int group = 0; group < d; group++) {
                char chars[1000];
                int charCount = 0;
                
                for (int pos = start + group; pos <= end; pos += d) {
                    chars[charCount++] = s[pos];
                }
                
                int left = 0, right = charCount - 1;
                while (left < right) {
                    if (chars[left] != chars[right]) {
                        currCost++;
                    }
                    left++;
                    right--;
                }
            }
            
            if (currCost < minCost) {
                minCost = currCost;
            }
        }
    }
    
    return minCost == INT_MAX ? 0 : minCost;
}

int minimumChanges(char* s, int k) {
    int n = strlen(s);
    
    // Precompute costs
    int cost[1000][1000];
    memset(cost, 0, sizeof(cost));
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            cost[i][j] = getSemiPalindromeCost(s, i, j);
        }
    }
    
    // DP
    int dp[1001][101];
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        int maxJ = i < k ? i : k;
        for (int j = 1; j <= maxJ; j++) {
            for (int prev = j - 1; prev < i; prev++) {
                if (dp[prev][j - 1] != INT_MAX) {
                    int newCost = dp[prev][j - 1] + cost[prev][i - 1];
                    if (newCost < dp[i][j]) {
                        dp[i][j] = newCost;
                    }
                }
            }
        }
    }
    
    return dp[n][k] == INT_MAX ? -1 : dp[n][k];
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* clean = s;
    while (*clean == '"' || *clean == ' ') clean++;
    int len = strlen(clean);
    while (len > 0 && (clean[len-1] == '"' || clean[len-1] == '\n')) {
        clean[--len] = '\0';
    }
    
    scanf("%d", &k);
    
    printf("%d\n", minimumChanges(clean, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ + n²k)

O(n³) to precompute all substring costs (n² substrings × n divisors), O(n²k) for DP table filling

⚠ Quadratic Growth

Space Complexity

O(n² + nk)

O(n²) for storing all substring costs, O(nk) for DP table

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 200
1 ≤ k ≤ s.length
s consists of lowercase English letters only
s must be partitioned into exactly k non-empty substrings
Semi-palindromes with length 1 have cost 0 (no valid divisors)

27.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler