Welcome to Subscribe On Youtube
Formatted question description: https://leetcode.ca/all/1278.html
1278. Palindrome Partitioning III (Hard)
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 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.
Related Topics:
Dynamic Programming
Solution 1. DP
Let dp[k][i][j] be the minimal number of changes needed for s[i..j] with k divides.
dp[1][i][i] = 0
dp[1][i][j] = dp[1][i + 1][j - 1] If s[i] == s[j]
= 1 + dp[1][i + 1][j - 1] If s[i] != s[j]
dp[k][i][j] = min( dp[k-1][i][t] + dp[1][t+1][j] | i + k - 1 <= t < j )
// OJ: https://leetcode.com/problems/palindrome-partitioning-iii/
// Time: O(K * N^3)
// Space: O(K * N^3)
class Solution {
typedef long long LL;
inline void setMin(LL &a, LL b) { a = min(a, b); }
public:
int palindromePartition(string s, int K) {
int N = s.size();
vector<vector<vector<LL>>> dp(K + 1, vector<vector<LL>>(N, vector<LL>(N, 1e9)));
for (int i = 0; i < N; ++i) dp[1][i][i] = 0;
for (int i = N - 2; i >= 0; --i) {
for (int j = i + 1; j < N; ++j) {
dp[1][i][j] = (s[i] != s[j]) + (i + 1 <= j - 1 ? dp[1][i + 1][j - 1] : 0);
}
}
for (int k = 2; k <= K; ++k) {
for (int i = N - 2; i >= 0; --i) {
for (int j = i + k - 1; j < N; ++j) {
for (int t = i + k - 2; t < j; ++t) {
setMin(dp[k][i][j], dp[k - 1][i][t] + dp[1][t + 1][j]);
}
}
}
}
return dp[K][0][N - 1];
}
};
Solution 2. DP
In Solution 1, for the k >= 2 cases, we don’t need to iterate all i, j combinations.
Let pal[i][j] be the minimum changes needed to make s[i..j] palindrome.
Let dp[k][i] be the minimum changes needed for s[0..i] with k divides.
pal[i][i] = 0
pal[i][j] = dp[1][i + 1][j - 1] If s[i] == s[j]
= 1 + dp[1][i + 1][j - 1] If s[i] != s[j]
dp[1][i] = pal[0][i]
dp[k][i] = min( dp[k-1][j] + pal[j+1][i] | k-2 <= j < i )
// OJ: https://leetcode.com/problems/palindrome-partitioning-iii/
// Time: O(K * N^2)
// Space: O(K * N^2)
class Solution {
typedef long long LL;
inline void setMin(LL &a, LL b) { a = min(a, b); }
public:
int palindromePartition(string s, int K) {
int N = s.size();
vector<vector<LL>> pal(N, vector<LL>(N));
vector<vector<LL>> dp(K + 1, vector<LL>(N, 1e9));
for (int i = N - 2; i >= 0; --i) {
for (int j = i + 1; j < N; ++j) {
pal[i][j] = (s[i] != s[j]) + pal[i + 1][j - 1];
}
}
for (int i = 0; i < N; ++i) dp[1][i] = pal[0][i];
for (int k = 2; k <= K; ++k) {
for (int i = k - 1; i < N; ++i) {
for (int j = k - 2; j < i; ++j) {
setMin(dp[k][i], dp[k - 1][j] + pal[j + 1][i]);
}
}
}
return dp[K][N - 1];
}
};
-
class Solution { public int palindromePartition(String s, int k) { int length = s.length(); int[][] costs = new int[length][length]; for (int i = 1; i < length; i++) { if (s.charAt(i - 1) != s.charAt(i)) costs[i - 1][i] = 1; } for (int i = length - 3; i >= 0; i--) { for (int j = i + 2; j < length; j++) { costs[i][j] = costs[i + 1][j - 1]; if (s.charAt(i) != s.charAt(j)) costs[i][j]++; } } int[][] dp = new int[length + 1][k + 1]; for (int i = 0; i <= length; i++) { for (int j = 0; j <= k; j++) dp[i][j] = Integer.MAX_VALUE; } dp[0][0] = 0; for (int i = 1; i <= length; i++) { int max = Math.min(i, k); for (int j = 1; j <= max; j++) { if (j == 1) dp[i][j] = costs[0][i - 1]; else { for (int start = j - 1; start < i; start++) dp[i][j] = Math.min(dp[i][j], dp[start][j - 1] + costs[start][i - 1]); } } } return dp[length][k]; } } ############ 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]; } } -
// OJ: https://leetcode.com/problems/palindrome-partitioning-iii/ // Time: O(K * N^3) // Space: O(K * N^3) class Solution { typedef long long LL; inline void setMin(LL &a, LL b) { a = min(a, b); } public: int palindromePartition(string s, int K) { int N = s.size(); vector<vector<vector<LL>>> dp(K + 1, vector<vector<LL>>(N, vector<LL>(N, 1e9))); for (int i = 0; i < N; ++i) dp[1][i][i] = 0; for (int i = N - 2; i >= 0; --i) { for (int j = i + 1; j < N; ++j) { dp[1][i][j] = (s[i] != s[j]) + (i + 1 <= j - 1 ? dp[1][i + 1][j - 1] : 0); } } for (int k = 2; k <= K; ++k) { for (int i = N - 2; i >= 0; --i) { for (int j = i + k - 1; j < N; ++j) { for (int t = i + k - 2; t < j; ++t) { setMin(dp[k][i][j], dp[k - 1][i][t] + dp[1][t + 1][j]); } } } } return dp[K][0][N - 1]; } }; -
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] -
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] } func min(a, b int) int { if a < b { return a } return b }