Output smallest number k palindrome - algorithm

Question

With a dynamic programming problem, I am trying to come up with an english algorithm, memo table, best case, and recursive calls to fill the table for the following problem:
Given a string s of length n, design an algorithm that outputs the smallest number k such that s = w1w2 . . . wk where each wi is a palindrome. In other words, find the smallest k such that s can be written as a concatenation of k palindromes. For the definition of a palindrome see practice problems. For example if s = "add" then the algorithm should output k = 2 since we can take w1 ="a" and w2 ="dd". On the other hand, if s = "ada", then the algorithm should output k = 1.
I came up with the following algorithm:
Start
Declare variables s as string, n as integer, k as integer, i as integer.
Initialize k to 1
Read s
n<-length of string s
while i is less then n-1
if s[i]==s[i+1] then
k++
end if
display k
End
However, I am unsure how to come up with the memoization table, best case, and the recursive steps needed to fill the table.

Answer 1

In dynamic programming, memo table saves the answer for the sub problem of the actual problem. Combining these sub problem answer we can calculate the answer for the actual problem.
For this problem, actual problem is to find minimum k palindrome for string s. So, sub problem could be like what is the minimum k for part/substring's of string s. To simplify it, if we know the answer for substring s[0:i] and s[i+1:length(s)-1], then we can calculate the answer for s[0:length(s)-1] = s[0:i] + s[i+1:length(s)-1].
From this we can easily form our recursive relation:
minKPalindrome(start, end) = minKPalindrome(start, i) + minKPalindrome(i+1, end), (start < i < end)
here, minKPalindrome(start, end) is function that return minimum k plaindrome for s[start:end] substring
Possible base cases:
- if start > end , return answer 0
- s[start:end] is palindrome, so return answer is 1
Recursive algorithm:
memo[start][end] = contains answer for s[start:end]
minKPalindrome(start, end) {
if s[start:end] is palindrome {
return 1
}
if ans is already saved in memo[start][end] {
return memo[start][end]
}
memo[start][end] = end - start + 1 // set maximum possible answer
for i = start+1 to end-1 {
memo[start][end] = min( memo[start][end], minKPalindrome(start, i) + minKPalindrome(i+1, end))
}
return memo[start][end]
}
Optimized algorithm:
Generalize previous recursive relation:
minKPalindrome(s[start: end]) = minKPalindrome(s[start, i]) + minKPalindrome(s[i+1, end])
or,
minKPalindrome(s[start: end]) = minKPalindrome(prefix of s) + minKPalindrome(suffix of s)
Instead checking for every prefix of string s, we can just check for only the prefix that are palindrome.
if start[start:i] is palindrome {
minKPalindrome(s[start: end]) = 1 + minKPalindrome(s[i+1:end])
}
base case:
- if start > end, return 0
recursive algorithm:
memo[start] = contains answer for s[start:end]
end = lenght(s) - 1
minKPalindrome(start, end) {
if start > end {
return 0
}
if ans is already saved in memo[start] {
return memo[start]
}
memo[start] = end - start + 1 // set maximum possible answer
for i = start to end {
if s[start:i] is palindrome {
memo[start] = min( memo[start], 1 + minKPalindrome(i+1, end))
}
}
return memo[start]
}
iterative algorithm:
for iterative algorithm we will save answer for for prefix of string s.
memo[i] = contains answer for s[0:i]
for i = 0 to length(s)-1 {
for j= 0 to i {
if s[j:i] is palindrome {
memo[i] = min( memo[i], 1 + memo[j-1])
}
}
}