1278. Palindrome Partitioning III
Description
You are given a string s containing lowercase letters and an integer k. You need to :
- First, change some characters of
sto other lowercase English letters. - Then divide
sintoknon-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.sonly contains lowercase English letters.
Solutions
Solution 1: Dynamic Programming
We define $f[i][j]$ to represent the minimum number of changes needed to partition the first $i$ characters of the string $s$ into $j$ palindromic substrings. We assume the index $i$ starts from 1, and the answer is $f[n][k]$.
For $f[i][j]$, we can enumerate the position $h$ of the last character of the $(j-1)$-th palindromic substring. Then $f[i][j]$ is equal to the minimum value of $f[h][j-1] + g[h][i-1]$, where $g[h][i-1]$ represents the minimum number of changes needed to turn the substring $s[h..i-1]$ into a palindrome (this part can be preprocessed with a time complexity of $O(n^2)$).
The time complexity is $O(n^2 \times k)$, and the space complexity is $O(n \times (n + k))$. Where $n$ is the length of the string $s$.
Python3
class Solution:
def palindromePartition(self, s: str, k: int) -> int:
n = len(s)
g = [[0] * n for _ in range(n)]
for i in range(n - 1, -1, -1):
for j in range(i + 1, n):
g[i][j] = int(s[i] != s[j])
if i + 1 < j:
g[i][j] += g[i + 1][j - 1]
f = [[0] * (k + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(1, min(i, k) + 1):
if j == 1:
f[i][j] = g[0][i - 1]
else:
f[i][j] = inf
for h in range(j - 1, i):
f[i][j] = min(f[i][j], f[h][j - 1] + g[h][i - 1])
return f[n][k]
Java
class Solution {
public int palindromePartition(String s, int k) {
int n = s.length();
int[][] g = new int[n][n];
for (int i = n - 1; i >= 0; --i) {
for (int j = i; j < n; ++j) {
g[i][j] = s.charAt(i) != s.charAt(j) ? 1 : 0;
if (i + 1 < j) {
g[i][j] += g[i + 1][j - 1];
}
}
}
int[][] f = new int[n + 1][k + 1];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= Math.min(i, k); ++j) {
if (j == 1) {
f[i][j] = g[0][i - 1];
} else {
f[i][j] = 10000;
for (int h = j - 1; h < i; ++h) {
f[i][j] = Math.min(f[i][j], f[h][j - 1] + g[h][i - 1]);
}
}
}
}
return f[n][k];
}
}
C++
class Solution {
public:
int palindromePartition(string s, int k) {
int n = s.size();
vector<vector<int>> g(n, vector<int>(n));
for (int i = n - 1; i >= 0; --i) {
for (int j = i; j < n; ++j) {
g[i][j] = s[i] != s[j] ? 1 : 0;
if (i + 1 < j) g[i][j] += g[i + 1][j - 1];
}
}
vector<vector<int>> f(n + 1, vector<int>(k + 1));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= min(i, k); ++j) {
if (j == 1) {
f[i][j] = g[0][i - 1];
} else {
f[i][j] = 10000;
for (int h = j - 1; h < i; ++h) {
f[i][j] = min(f[i][j], f[h][j - 1] + g[h][i - 1]);
}
}
}
}
return f[n][k];
}
};
Go
func palindromePartition(s string, k int) int {
n := len(s)
g := make([][]int, n)
for i := range g {
g[i] = make([]int, n)
}
for i := n - 1; i >= 0; i-- {
for j := 1; j < n; j++ {
if s[i] != s[j] {
g[i][j] = 1
}
if i+1 < j {
g[i][j] += g[i+1][j-1]
}
}
}
f := make([][]int, n+1)
for i := range f {
f[i] = make([]int, k+1)
}
for i := 1; i <= n; i++ {
for j := 1; j <= min(i, k); j++ {
if j == 1 {
f[i][j] = g[0][i-1]
} else {
f[i][j] = 100000
for h := j - 1; h < i; h++ {
f[i][j] = min(f[i][j], f[h][j-1]+g[h][i-1])
}
}
}
}
return f[n][k]
}
TypeScript
function palindromePartition(s: string, k: number): number {
const n = s.length;
const g: number[][] = Array.from({ length: n }, () => Array(n).fill(0));
for (let i = n - 1; i >= 0; i--) {
for (let j = i + 1; j < n; j++) {
g[i][j] = s[i] !== s[j] ? 1 : 0;
if (i + 1 < j) {
g[i][j] += g[i + 1][j - 1];
}
}
}
const f: number[][] = Array.from({ length: n + 1 }, () => Array(k + 1).fill(0));
for (let i = 1; i <= n; i++) {
for (let j = 1; j <= Math.min(i, k); j++) {
if (j === 1) {
f[i][j] = g[0][i - 1];
} else {
f[i][j] = 1 << 30;
for (let h = j - 1; h < i; h++) {
f[i][j] = Math.min(f[i][j], f[h][j - 1] + g[h][i - 1]);
}
}
}
}
return f[n][k];
}
Rust
impl Solution {
pub fn palindrome_partition(s: String, k: i32) -> i32 {
let n = s.len();
let s: Vec<char> = s.chars().collect();
let mut g = vec![vec![0; n]; n];
for i in (0..n).rev() {
for j in i + 1..n {
g[i][j] = if s[i] != s[j] { 1 } else { 0 };
if i + 1 < j {
g[i][j] += g[i + 1][j - 1];
}
}
}
let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
let inf = i32::MAX;
for i in 1..=n {
for j in 1..=i.min(k as usize) {
if j == 1 {
f[i][j] = g[0][i - 1];
} else {
f[i][j] = inf;
for h in (j - 1)..i {
f[i][j] = f[i][j].min(f[h][j - 1] + g[h][i - 1]);
}
}
}
}
f[n][k as usize]
}
}