The key idea is to match the smallest possible prefix and suffix that are equal, then recursively solve the problem for the substring in between. This works because the palindrome decomposition requires mirrored chunks from both ends.
classSolution {
public:int longestDecomposition(string s) {
int n = s.size(), ans =0, l =0, r = n;
while (l < r) {
int len =1;
while (l + len <= r - len && s.substr(l, len) != s.substr(r - len, len)) ++len;
if (l + len > r - len) break;
ans +=2;
l += len;
r -= len;
}
if (l < r) ans++;
return ans;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
funclongestDecomposition(sstring) int {
n, ans, l, r:= len(s), 0, 0, len(s)
forl < r {
length:=1forl+length<=r-length&&s[l:l+length] !=s[r-length:r] {
length++ }
ifl+length > r-length {
break }
ans+=2l+=lengthr-=length }
ifl < r {
ans++ }
returnans}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
classSolution {
publicintlongestDecomposition(String s) {
int n = s.length(), ans = 0, l = 0, r = n;
while (l < r) {
int len = 1;
while (l + len <= r - len &&!s.substring(l, l+len).equals(s.substring(r-len, r))) ++len;
if (l + len > r - len) break;
ans += 2;
l += len;
r -= len;
}
if (l < r) ans++;
return ans;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
classSolution {
funlongestDecomposition(s: String): Int {
var l = 0var r = s.length
var ans = 0while (l < r) {
var len = 1while (l + len <= r - len && s.substring(l, l+len) != s.substring(r-len, r)) len++if (l + len > r - len) break ans +=2 l += len
r -= len
}
if (l < r) ans++return ans
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
classSolution:
deflongestDecomposition(self, s: str) -> int:
n, ans, l, r = len(s), 0, 0, len(s)
while l < r:
length =1while l + length <= r - length and s[l:l+length] != s[r-length:r]:
length +=1if l + length > r - length:
break ans +=2 l += length
r -= length
if l < r:
ans +=1return ans
impl Solution {
pubfnlongest_decomposition(s: String) -> i32 {
let (mut l, mut r, n) = (0, s.len(), s.len());
let s = s.as_bytes();
letmut ans =0;
while l < r {
letmut len =1;
while l + len <= r - len &&&s[l..l+len] !=&s[r-len..r] {
len +=1;
}
if l + len > r - len {
break;
}
ans +=2;
l += len;
r -= len;
}
if l < r {
ans +=1;
}
ans
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
classSolution {
longestDecomposition(s: string):number {
letn=s.length, ans=0, l=0, r=n;
while (l<r) {
letlen=1;
while (l+len<=r-len&&s.slice(l, l+len) !==s.slice(r-len, r)) ++len;
if (l+len>r-len) break;
ans+=2;
l+=len;
r-=len;
}
if (l<r) ans++;
returnans;
}
}