Minimum Changes to Make K Semi-palindromes

Minimum Changes to Make K Semi-palindromes - Problem

Given a string s and an integer k, partition s into k substrings such that the letter changes needed to make each substring a semi-palindrome are minimized.

Return the minimum number of letter changes required.

A semi-palindrome is a special type of string that can be divided into palindromes based on a repeating pattern. To check if a string is a semi-palindrome:

Choose a positive divisor d of the string's length. d can range from 1 up to, but not including, the string's length.
For a string of length 1, it does not have a valid divisor as per this definition, since the only divisor is its length, which is not allowed.
For a given divisor d, divide the string into groups where each group contains characters from the string that follow a repeating pattern of length d.
Specifically, the first group consists of characters at positions 1, 1+d, 1+2d, ...; the second group includes characters at positions 2, 2+d, 2+2d, ... etc.
The string is considered a semi-palindrome if each of these groups forms a palindrome.

Example: Consider the string "abcabc" with length 6. Valid divisors are 1, 2, and 3. For d = 3: Group 1 (positions 1,4): "aa", Group 2 (positions 2,5): "bb", Group 3 (positions 3,6): "cc". All groups form palindromes, so "abcabc" is a semi-palindrome.

Input & Output

Example 1 — Perfect Semi-palindromes

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

› Output: 0

💡 Note: Partition into "abc" and "abc". Both are already semi-palindromes with d=3: groups (a,a), (b,b), (c,c) are all palindromes. Cost = 0 + 0 = 0

Example 2 — Need Changes

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

› Output: 2

💡 Note: Best partition is "abc" | "def". For "abc" with d=1: need to change 'a'→'c' or 'c'→'a' (1 change). For "def" with d=1: need to change 'd'→'f' or 'f'→'d' (1 change). Total = 1 + 1 = 2

Example 3 — Single Characters

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

› Output: 0

💡 Note: Partition into "a", "b", "c". Single characters have no valid divisors, so cost is 0 for each. Total = 0 + 0 + 0 = 0

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is to pre-compute the cost to convert any substring to a semi-palindrome, then use dynamic programming to find the optimal way to partition the string into k parts. Best approach uses 2D DP with memoization. Time: O(n³ + n²k), Space: O(n² + nk)

Common Approaches

✓ Brute Force Recursion

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

For each position, try making a cut and recursively solve for the remaining string. Calculate the cost to convert each substring to a semi-palindrome and find the minimum total cost.

Dynamic Programming with Memoization

⏱️ Time: O(n³ + n²k) Space: O(n² + nk)

First pre-compute the cost to convert any substring to a semi-palindrome. Then use dynamic programming where dp[i][j] represents the minimum cost to partition the first i characters into j parts.

Brute Force Recursion — Algorithm Steps

Try every possible first substring
Recursively partition the remaining string into k-1 parts
Calculate semi-palindrome conversion cost for each substring
Return minimum total cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

String 'abcabc' with k=2

Try Cuts

Recursively try every position to make cuts

Calculate

Compute semi-palindrome cost for each substring

Code -

solution.c — C

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

int* getDivisors(int length, int* count) {
    int* divisors = malloc(length * sizeof(int));
    *count = 0;
    for (int d = 1; d < length; d++) {
        if (length % d == 0) {
            divisors[(*count)++] = d;
        }
    }
    return divisors;
}

int costToSemiPalindrome(const char* substr) {
    int len = strlen(substr);
    if (len <= 1) return 0;
    
    int divisorCount;
    int* divisors = getDivisors(len, &divisorCount);
    if (divisorCount == 0) {
        free(divisors);
        return INT_MAX;
    }
    
    int minCost = INT_MAX;
    for (int i = 0; i < divisorCount; i++) {
        int d = divisors[i];
        int cost = 0;
        
        char** groups = malloc(d * sizeof(char*));
        int* groupSizes = calloc(d, sizeof(int));
        
        for (int j = 0; j < d; j++) {
            groups[j] = malloc(len * sizeof(char));
        }
        
        for (int j = 0; j < len; j++) {
            int groupIdx = j % d;
            groups[groupIdx][groupSizes[groupIdx]++] = substr[j];
        }
        
        for (int j = 0; j < d; j++) {
            int left = 0, right = groupSizes[j] - 1;
            while (left < right) {
                if (groups[j][left] != groups[j][right]) {
                    cost++;
                }
                left++;
                right--;
            }
        }
        
        for (int j = 0; j < d; j++) {
            free(groups[j]);
        }
        free(groups);
        free(groupSizes);
        
        if (cost < minCost) {
            minCost = cost;
        }
    }
    
    free(divisors);
    return minCost == INT_MAX ? 0 : minCost;
}

int backtrack(const char* s, int start, int partsLeft, int n) {
    if (partsLeft == 0) {
        return start == n ? 0 : INT_MAX;
    }
    if (start >= n) return INT_MAX;
    
    int minCost = INT_MAX;
    for (int end = start + 1; end <= n; end++) {
        char* substr = malloc((end - start + 1) * sizeof(char));
        strncpy(substr, s + start, end - start);
        substr[end - start] = '\0';
        
        int cost = costToSemiPalindrome(substr);
        int remainingCost = backtrack(s, end, partsLeft - 1, n);
        
        if (cost != INT_MAX && remainingCost != INT_MAX) {
            int totalCost = cost + remainingCost;
            if (totalCost < minCost) {
                minCost = totalCost;
            }
        }
        
        free(substr);
    }
    
    return minCost;
}

int solution(char* s, int k) {
    return backtrack(s, 0, k, strlen(s));
}

int main() {
    char s[1000];
    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(2^n × n³)

Exponential partitions with cubic cost calculation for each substring

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n levels

⚠ Quadratic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler