# Solving Leetcode Interviews in Seconds with AI: Palindrome Partitioning III


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1278" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a string s containing lowercase letters and an integer k. You need to :  First, change some characters of s to other lowercase English letters. Then divide s into k non-empty disjoint substrings such that each substring is a palindrome.  Return the minimal number of characters that you need to change to divide the string.   Example 1:  Input: s = "abc", k = 2 Output: 1 Explanation: You can split the string into "ab" and "c", and change 1 character in "ab" to make it palindrome.  Example 2:  Input: s = "aabbc", k = 3 Output: 0 Explanation: You can split the string into "aa", "bb" and "c", all of them are palindrome. Example 3:  Input: s = "leetcode", k = 8 Output: 0    Constraints:  1 <= k <= s.length <= 100. s only contains lowercase English letters.  

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Dynamic Programming:** Use dynamic programming to store and reuse the minimal changes needed for substrings ending at each index for different `k` values.
*   **Palindrome Cost Calculation:** Precompute the cost (number of changes needed) to make each substring a palindrome. This avoids recalculating it repeatedly.
*   **Optimal Substructure:** The minimal changes for `k` substrings ending at index `i` is the minimum of (minimal changes for `k-1` substrings ending at `j`) + (cost to make substring `s[j+1:i+1]` a palindrome) for all `j < i`.

*   **Runtime Complexity:** O(n^3), where n is the length of the string. **Storage Complexity:** O(n^2).

	
	# Code
	```python
	def solve():
    s = input()
    k = int(input())
    n = len(s)

    # cost[i][j] is the cost to make s[i:j+1] a palindrome
    cost = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(i, n):
            l, r = i, j
            while l < r:
                if s[l] != s[r]:
                    cost[i][j] += 1
                l += 1
                r -= 1

    # dp[i][j] is the minimum cost to split s[:i+1] into j+1 palindromes
    dp = [[float('inf')] * (k) for _ in range(n)]

    # Base case: k = 1 (splitting into 1 palindrome)
    for i in range(n):
        dp[i][0] = cost[0][i]

    # Iterate for k > 1
    for num_palindromes in range(1, k):
        for i in range(num_palindromes, n): # Must have at least num_palindromes characters for the current k value
            for j in range(i):
                dp[i][num_palindromes] = min(dp[i][num_palindromes], dp[j][num_palindromes-1] + cost[j+1][i])

    return dp[n-1][k-1]

print(solve())
	```