普通排序：时间 O(nlogn) / 空间 O(1)

前半部分顺序排序，后半部分逆序排序。

class Solution {
public:
  string smallestPalindrome(string s) {
    const int n = s.length();
    sort(begin(s), begin(s) + n / 2);
    sort(rbegin(s), rbegin(s) + n / 2);
    return s;
  }
};

计数排序：时间：O(n)，空间：O(n) -> O(1)

首尾一起写

// 7 ms, 54.65MB
class Solution {
public:
  string smallestPalindrome(string s) {
    vector<int> f(128);
    for (size_t i = 0; i < s.size() / 2; ++i)
      ++f[s[i]];
    auto h=begin(s);
    auto t=rbegin(s);
    for (char c = 'a'; c <= 'z'; ++c)
      while (f[c]--)
        *h++ = *t++ = c;
    return s;
  }
};

Create the longest possible palindrome by selecting some elements from words and concatenating them in any order. Each element can be selected at most once.

Return the length of the longest palindrome that you can create. If it is impossible to create any palindrome, return 0.

A palindrome is a string that reads the same forward and backward.

Example 1:

Input: words = ["lc","cl","gg"]
Output: 6
Explanation: One longest palindrome is "lc" + "gg" + "cl" = "lcggcl", of length 6.
Note that "clgglc" is another longest palindrome that can be created.

Example 2:

Input: words = ["ab","ty","yt","lc","cl","ab"]
Output: 8
Explanation: One longest palindrome is "ty" + "lc" + "cl" + "yt" = "tylcclyt", of length 8.
Note that "lcyttycl" is another longest palindrome that can be created.

Example 3:

Input: words = ["cc","ll","xx"]
Output: 2
Explanation: One longest palindrome is "cc", of length 2.
Note that "ll" is another longest palindrome that can be created, and so is "xx".

Constraints:

• 1 <= words.length <= 105
• words[i].length == 2
• words[i] consists of lowercase English letters.

Solution: Match mirrored words

For any pair of mirrored words, e.g. ‘ab’ <-> ‘ba’ or ‘aa’ <-> ‘aa’, we can extend the existing longest palindrome, ans += 4.
For any unpaired words with same letter, e.g. ‘cc’, we can only use one and put in the middle of the pladrome, ans += 2.

Time complexity: O(n)
Space complexity: O(26*26)

// Author: Huahua
class Solution {
public:
  int longestPalindrome(vector<string>& words) {
    int ans = 0;
    int same = 0;
    vector<vector<int>> m(26, vector<int>(26));          
    for (const string& word : words) {      
      const int a = word[0] - 'a';
      const int b = word[1] - 'a';
      if (m[b][a]) {
        --m[b][a];
        ans += 4;
      } else {
        ++m[a][b];
      }
    }
    for (int i = 0; i < 26; ++i)
      if (m[i][i]) {
        ans += 2;
        break;
      }
    return ans;
  }
};

Note that even if there are multiple ways to obtain the same subsequence, it is still only counted once.

A palindrome is a string that reads the same forwards and backwards.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

• For example, "ace" is a subsequence of "abcde".

Example 1:

Input: s = "aabca"
Output: 3
Explanation: The 3 palindromic subsequences of length 3 are:
- "aba" (subsequence of "aabca")
- "aaa" (subsequence of "aabca")
- "aca" (subsequence of "aabca")

Example 2:

Input: s = "adc"
Output: 0
Explanation: There are no palindromic subsequences of length 3 in "adc".

Example 3:

Input: s = "bbcbaba"
Output: 4
Explanation: The 4 palindromic subsequences of length 3 are:
- "bbb" (subsequence of "bbcbaba")
- "bcb" (subsequence of "bbcbaba")
- "bab" (subsequence of "bbcbaba")
- "aba" (subsequence of "bbcbaba")

Constraints:

• 3 <= s.length <= 105
• s consists of only lowercase English letters.

Solution: Enumerate first character of a palindrome

For a length 3 palindrome, we just need to enumerate the first character c.
We found the first and last occurrence of c in original string and scan the middle part to see how many unique characters there.

e.g. aabca
Enumerate from a to z, looking for a*a, b*b, …, z*z.
For a*a, aabca, we found first and last a, in between is abc, which has 3 unique letters.
We can use a hastable or a bitset to track unique letters.

Time complexity: O(26*n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countPalindromicSubsequence(string s) {
    auto count = [&](char c) -> int {
      int l = s.find_first_of(c);
      int r = s.find_last_of(c);
      if (l == string::npos || r == string::npos) return 0;
      bitset<26> m;
      for (int i = l + 1; i < r; ++i)
        m.set(s[i] - 'a');
      return m.count();
    };
    int ans = 0;
    for (char c = 'a'; c <= 'z'; ++c)
      ans += count(c);
    return ans;
  }
};

A string is palindromic if it reads the same forward and backward.

Example 1:

Input: words = ["abc","car","ada","racecar","cool"]
Output: "ada"
Explanation: The first string that is palindromic is "ada".
Note that "racecar" is also palindromic, but it is not the first.

Example 2:

Input: words = ["notapalindrome","racecar"]
Output: "racecar"
Explanation: The first and only string that is palindromic is "racecar".

Example 3:

Input: words = ["def","ghi"]
Output: ""
Explanation: There are no palindromic strings, so the empty string is returned.

Constraints:

• 1 <= words.length <= 100
• 1 <= words[i].length <= 100
• words[i] consists only of lowercase English letters.

Solution: Brute Force

Enumerate each word and check whether it’s a palindrome or not.

Time complexity: O(n * l)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string firstPalindrome(vector<string>& words) {
    auto isPalindrome = [](string_view s) {
      size_t l = s.size();
      for (size_t i = 0; i < l / 2; ++i)
        if (s[i] != s[l - i - 1]) return false;
      return true;
    };
    for (const string& word : words)
      if (isPalindrome(word)) return word;
    return "";
  }
};

You are given two strings, word1 and word2. You want to construct a string in the following manner:

• Choose some non-empty subsequence subsequence1 from word1.
• Choose some non-empty subsequence subsequence2 from word2.
• Concatenate the subsequences: subsequence1 + subsequence2, to make the string.

Return the length of the longest palindrome that can be constructed in the described manner. If no palindromes can be constructed, return 0.

A subsequence of a string s is a string that can be made by deleting some (possibly none) characters from s without changing the order of the remaining characters.

A palindrome is a string that reads the same forward as well as backward.

Example 1:

Input: word1 = "cacb", word2 = "cbba"
Output: 5
Explanation: Choose "ab" from word1 and "cba" from word2 to make "abcba", which is a palindrome.

Example 2:

Input: word1 = "ab", word2 = "ab"
Output: 3
Explanation: Choose "ab" from word1 and "a" from word2 to make "aba", which is a palindrome.

Example 3:

Input: word1 = "aa", word2 = "bb"
Output: 0
Explanation: You cannot construct a palindrome from the described method, so return 0.

Constraints:

• 1 <= word1.length, word2.length <= 1000
• word1 and word2 consist of lowercase English letters.

Solution: DP

Similar to 花花酱 LeetCode 516. Longest Palindromic Subsequence

Let s = word1 + word2, build dp table on s. We just need to make sure there’s at least one char from each string.

Time complexity: O((m+n)^2)
Space complexity: O((m+n)^2)

// Author: Huahua
class Solution {
public:
  int longestPalindrome(string word1, string word2) {
    const int l1 = word1.length();
    const int l2 = word2.length();
    string s = word1 + word2;
    const int n = l1 + l2;
    vector<vector<int>> dp(n, vector<int>(n));
    for (int i = 0; i < n; ++i) dp[i][i] = 1;
    for (int l = 2; l <= n; ++l)
      for (int i = 0, j = i + l - 1; j < n; ++i, ++j) {
        if (s[i] == s[j])
          dp[i][j] = dp[i + 1][j - 1] + 2;
        else
          dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
      }
    
    int ans = 0;
    for (int i = 0; i < l1; ++i)
      for (int j = 0; j < l2; ++j)
        if (word1[i] == word2[j])
          ans = max(ans, dp[i][l1 + j]);
    return ans;
  }
};

O(m+n) Space complexity

// Author: Huahua
class Solution {
public:
  int longestPalindrome(string word1, string word2) {
    const int l1 = word1.length();
    const int l2 = word2.length();
    string s = word1 + word2;
    const int n = l1 + l2;
    vector<int> dp1(n, 1), dp2(n);
    int ans = 0;
    for (int l = 2; l <= n; ++l) {
      vector<int> dp(n);
      for (int i = 0, j = i + l - 1; j < n; ++i, ++j) {
        if (s[i] == s[j]) {
          dp[i] = dp2[i + 1] + 2;
          if (i < l1 && j >= l1)
            ans = max(ans, dp[i]);
        } else {
          dp[i] = max(dp1[i + 1], dp1[i]);
        }
      }
      // dp2, dp1 = dp1, dp
      dp1.swap(dp); 
      dp2.swap(dp);
    }
    return ans;
  }
};

You are given two strings a and b of the same length. Choose an index and split both strings at the same index, splitting a into two strings: aprefix and asuffix where a = aprefix + asuffix, and splitting b into two strings: bprefix and bsuffix where b = bprefix + bsuffix. Check if aprefix + bsuffix or bprefix + asuffix forms a palindrome.

When you split a string s into sprefix and ssuffix, either ssuffix or sprefix is allowed to be empty. For example, if s = "abc", then "" + "abc", "a" + "bc", "ab" + "c" , and "abc" + "" are valid splits.

Return true if it is possible to form a palindrome string, otherwise return false.

Notice that x + y denotes the concatenation of strings x and y.

Example 1:

Input: a = "x", b = "y"
Output: true
Explaination: If either a or b are palindromes the answer is true since you can split in the following way:
aprefix = "", asuffix = "x"
bprefix = "", bsuffix = "y"
Then, aprefix + bsuffix = "" + "y" = "y", which is a palindrome.

Example 2:

Input: a = "abdef", b = "fecab"
Output: true

Example 3:

Input: a = "ulacfd", b = "jizalu"
Output: true
Explaination: Split them at index 3:
aprefix = "ula", asuffix = "cfd"
bprefix = "jiz", bsuffix = "alu"
Then, aprefix + bsuffix = "ula" + "alu" = "ulaalu", which is a palindrome.

Example 4:

Input: a = "xbdef", b = "xecab"
Output: false

Constraints:

• 1 <= a.length, b.length <= 105
• a.length == b.length
• a and b consist of lowercase English letters

Solution: Greedy

Try to match the prefix of A and suffix of B (or the other way) as much as possible and then check whether the remaining part is a palindrome or not.

e.g. A = “abcxyzzz”, B = “uuuvvcba”
A’s prefix abc matches B’s suffix cba
We just need to check whether “xy” or “vv” is palindrome or not.
The concatenated string “abc|vvcba” is a palindrome, left abc is from A and vvcba is from B.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool checkPalindromeFormation(string a, string b) {
    auto isPalindrome = [](const string& s, int i, int j) {
      while (i < j && s[i] == s[j]) ++i, --j;        
      return i >= j;
    };
    auto check = [&isPalindrome](const string& a, const string& b) {
      int i = 0;
      int j = a.length() - 1;
      while (a[i] == b[j]) ++i, --j;
      return isPalindrome(a, i, j) || isPalindrome(b, i, j);
    };
    return check(a, b) || check(b, a);
  }
};

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.

A string is called palindrome if is one that reads the same backward as well as forward.

Example 1:

Input: s = "ababa"
Output: 1
Explanation: String is already palindrome

Example 2:

Input: s = "abb"
Output: 2
Explanation: "abb" -> "bb" -> "". 
Remove palindromic subsequence "a" then "bb".

Example 3:

Input: s = "baabb"
Output: 2
Explanation: "baabb" -> "b" -> "". 
Remove palindromic subsequence "baab" then "b".

Example 4:

Input: s = ""
Output: 0

Constraints:

• 0 <= s.length <= 1000
• s only consists of letters ‘a’ and ‘b’

Solution: Math

if s is empty => 0 step
if s is a palindrome => 1 step
Otherwise, 2 steps…
1. delete all the as
2. delete all the bs

Time complexity: O(n)
Space complexity: O(n) / O(1)

// Author: Huahua
class Solution {
public:
  int removePalindromeSub(string s) {
    if (s.empty()) return 0;
    if (s == string(rbegin(s), rend(s))) return 1;
    return 2;
  }
};

After doing so, return the final string.  If there is no way to do so, return the empty string.

Example 1:

Input: palindrome = "abccba"
Output: "aaccba"

Example 2:

Input: palindrome = "a"
Output: ""

Constraints:

• 1 <= palindrome.length <= 1000
• palindrome consists of only lowercase English letters.

Solution: Greedy

For the first half of the string, replace the first non ‘a’ character to ‘a’.

e.g. abcdcba => aacdcba

If not found which means the the entire string is ‘a’ expect the middle one if the length is odd, like aa or aba, replace the last character to ‘b’.

aa => ab
aba => abb

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string breakPalindrome(string palindrome) {
    const int n = palindrome.length();
    if (n == 1) return "";
    for (int i = 0; i < n / 2; ++i) {
      if (palindrome[i] != 'a') {
        palindrome[i] = 'a';
        return palindrome;
      }
    }
    palindrome.back() = 'b';
    return palindrome;
  }
};

Given a string s. In one step you can insert any character at any index of the string.

Return the minimum number of steps to make s palindrome.

A Palindrome String is one that reads the same backward as well as forward.

Example 1:

Input: s = "zzazz"
Output: 0
Explanation: The string "zzazz" is already palindrome we don't need any insertions.

Example 2:

Input: s = "mbadm"
Output: 2
Explanation: String can be "mbdadbm" or "mdbabdm".

Example 3:

Input: s = "leetcode"
Output: 5
Explanation: Inserting 5 characters the string becomes "leetcodocteel".

Example 4:

Input: s = "g"
Output: 0

Example 5:

Input: s = "no"
Output: 1

Constraints:

• 1 <= s.length <= 500
• All characters of s are lower case English letters.

Solution: DP

dp[i][j] := min chars to insert
dp[j][j] = dp[i-1][j+1] if s[i] == s[j] else min(dp[i+1][j] , dp[i][j-1]) + 1
base case: dp[i][i] = 0
ans: dp[0][n-1]

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  int minInsertions(string s) {
    const int n = s.length();
    vector<vector<int>> dp(n, vector<int>(n));
    
    for (int l = 2; l <= n; ++l)
      for (int i = 0, j = l - 1; j < n; ++i, ++j)        
        dp[i][j] = s[i] == s[j] ? dp[i + 1][j - 1] : min(dp[i + 1][j], dp[i][j - 1]) + 1;                        
    return dp[0][n - 1];
  }
};

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

Example:

Input: "aab"
Output: 1
Explanation: The palindrome partitioning ["aa","b"] could be produced using 1 cut.

Solution: DP

dp[i] := min cuts of s[0~i]
dp[i] = min{dp[j] + 1} if s[j+1~i] is a palindrome.

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  int minCut(string s) {
    const int n = s.length();
    // valid[i][j] = 1 if s[i~j] is palindrome, otherwise 0
    vector<vector<int>> valid(n, vector<int>(n, 1));
    
    // dp[i] = min cuts of s[0~i] 
    vector<int> dp(n, n);
    
    for (int l = 2; l <= n; ++l)
      for (int i = 0, j = i + l - 1; j < n; ++i, ++j)
        valid[i][j] = s[i] == s[j] && valid[i + 1][j - 1];
    
    for (int i = 0; i < n; ++i) {      
      if (valid[0][i]) {
        dp[i] = 0;
        continue;
      }
      for (int j = 0; j < i; ++j)
        if (valid[j + 1][i])
          dp[i] = min(dp[i], dp[j] + 1);      
    }
    return dp[n - 1];
  }
};

DP v2

// Author: Huahua
class Solution {
public:
  int minCut(string s) {
    const int n = s.length();        
    // dp[i] = min cuts of s[0~i] 
    vector<int> dp(n, n);    
    for (int m = 0; m < n; ++m)      
      for (int d = 0; d <= 1; ++d)
        for (int i = m, j = m + d; i >= 0 && j < n && s[i] == s[j]; --i, ++j)
          dp[j] = min(dp[j], (i ? (dp[i - 1] + 1) : 0));    
    return dp[n - 1];
  }
};

Related Problems

131. https://zxi.mytechroad.com/blog/searching/leetcode-131-palindrome-partitioning/
1278. https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-1278-palindrome-partitioning-iii/

Return all possible palindrome partitioning of s.

Example:

Input: "aab"
Output:
[
  ["aa","b"],
  ["a","a","b"]
]

Solution1: DP

dp[i] := ans of str[0:i]
dp[j] = { x + str[i:len] for x in dp[i] }, 0 <= i < len

Time complexity: O(2^n)
Space complexity: O(2^n)

// Author: Huahua
bool isPalindrome(const string& s) {
  const int n = s.length();
  for (int i = 0; i < n / 2; ++i)
    if (s[i] != s[n - 1 - i]) return false;
  return true;
}

class Solution {
public:
  vector<vector<string>> partition(string s) {    
    int n = s.length();    
    vector<vector<vector<string>>> dp(n + 1);    
    for (int len = 1; len <= n; ++len) {
      for (int i = 0; i < len; ++i) {
        string right = s.substr(i, len - i);
        if (!isPalindrome(right)) continue;
        if (i == 0) dp[len].push_back({right});
        for (const auto& p : dp[i]) {
          dp[len].push_back(p);
          dp[len].back().push_back(right);
        }        
      }
    }
    return dp[n];
  } 
};

Solution 2: DFS

Time complexity: O(2^n)
Space complexity: O(n)

// Author: Huahua
bool isPalindrome(const string& s, int l, int r) {
  while (l < r)
    if (s[l++] != s[r--]) return false;  
  return true;
}

class Solution {
public:
  vector<vector<string>> partition(string s) {    
    int n = s.length();    
    vector<vector<string>> ans;
    vector<string> cur;
    function<void(int)> dfs = [&](int start) {
      if (start == n) {
        ans.push_back(cur);
        return;
      }
      
      for (int i = start; i < n; ++i) {
        if (!isPalindrome(s, start, i)) continue;
        cur.push_back(s.substr(start, i - start + 1));
        dfs(i + 1);
        cur.pop_back();
      }
    };
    dfs(0);
    return ans;
  } 
};

For each query queries[i] = [left, right, k], we may rearrange the substring s[left], ..., s[right], and then choose up to k of them to replace with any lowercase English letter. 

If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.

Return an array answer[], where answer[i] is the result of the i-th query queries[i].

Note that: Each letter is counted individually for replacement so if for example s[left..right] = "aaa", and k = 2, we can only replace two of the letters.  (Also, note that the initial string s is never modified by any query.)

Example :

Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
Output: [true,false,false,true,true]
Explanation:
queries[0] : substring = "d", is palidrome.
queries[1] : substring = "bc", is not palidrome.
queries[2] : substring = "abcd", is not palidrome after replacing only 1 character.
queries[3] : substring = "abcd", could be changed to "abba" which is palidrome. Also this can be changed to "baab" first rearrange it "bacd" then replace "cd" with "ab".
queries[4] : substring = "abcda", could be changed to "abcba" which is palidrome.

Constraints:

• 1 <= s.length, queries.length <= 10^5
• 0 <= queries[i][0] <= queries[i][1] < s.length
• 0 <= queries[i][2] <= s.length
• s only contains lowercase English letters.

Solution: Prefix frequency

Compute the prefix frequency of each characters, then we can efficiently compute the frequency of each characters in the substring in O(1) time. Count the number odd frequency characters o, we can convert it to a palindrome if o / 2 <= k.

Time complexity:
preprocessing: O(n)
Query: O(1)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {
    vector<bool> ans;
    int n = s.length();
    vector<vector<int>> f(n + 1, vector<int>(26));
    for (int i = 0; i < n; ++i) {
      ++f[i][s[i] - 'a'];
      f[i + 1] = f[i];
    }
    for (const auto& q : queries) {      
      int l = q[0];
      int r = q[1];
      int k = q[2];      
      int o = 0;
      for (int i = 0; i < 26; ++i) {
        int c = f[r][i] - (l == 0 ? 0 : f[l - 1][i]);        
        o += c % 2;
      }
      ans.push_back(o / 2 <= k);
    }
    return ans;
  }
};

• Each a_i is a non-empty string;
• Their concatenation a_1 + a_2 + ... + a_k is equal to text;
• For all 1 <= i <= k,  a_i = a_{k+1 - i}.

Example 1:

Input: text = "ghiabcdefhelloadamhelloabcdefghi"
Output: 7
Explanation: We can split the string on "(ghi)(abcdef)(hello)(adam)(hello)(abcdef)(ghi)".

Example 2:

Input: text = "merchant"
Output: 1
Explanation: We can split the string on "(merchant)".

Example 3:

Input: text = "antaprezatepzapreanta"
Output: 11
Explanation: We can split the string on "(a)(nt)(a)(pre)(za)(tpe)(za)(pre)(a)(nt)(a)".

Example 4:

Input: text = "aaa"
Output: 3
Explanation: We can split the string on "(a)(a)(a)".

Solution: Greedy

Break the string when the shortest palindrome is found.
prefer to use string_view

Time complexity: O(n^2)
Space complexity: O(n)

// Author: Huahua, 0 ms, 8.7 ms
class Solution {
public:
  int longestDecomposition(string_view text) {    
    const int n = text.length();
    if (n == 0) return 0;
    for (int l = 1; l <= n / 2; ++l) {
      if (text.substr(0, l) == text.substr(n - l)) 
        return 2 + longestDecomposition(text.substr(l, n - 2 * l));
    }
    return 1;
  }
};

Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.

Example 1:

Input: 121
Output: true

Example 2:

Input: -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Example 3:

Input: 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

Follow up:

Could you solve it without converting the integer to a string?

Solution 1: Convert to string (cheating)

Time complexity: O(log10(x))

Space complexity: O(log10(x))

// Author: Huahua
class Solution {
public:
  bool isPalindrome(int x) {
    string s = to_string(x);    
    return s == string(rbegin(s), rend(s));
  }
};

Solution 2: Digit by Digit

Every time we compare the first and last digits of x, if they are not the same, return false. Otherwise, remove first and last digit and continue this process.

How can we achieve that via int math?

e.g. x = 9999, t = pow((10, int)log10(x)) = 1000

first digit: x / t, last digit: x % 10

then x = (x – x / t * t) / 10 removes first and last digits.

t /= 100 since we removed two digits.

x / t = 9 = 9 = x % 10, 9999 => 99

9 = 9, 99 => “”

Time complexity: O(log10(x) / 2)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool isPalindrome(int x) {
    if (x < 0) return false;
    int d = static_cast<int>(log10(x) + 1);
    int t = pow(10, d - 1);
    for (int i = 0; i < d / 2; ++i) {     
      if (x / t != x % 10) return false;
      x = (x - x / t * t) / 10;
      t /= 100;     
    }
    return true;
  }
};

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

Solution: DP

Try all possible i and find the longest palindromic string whose center is i (odd case) and i / i + 1 (even case).

Time complexity: O(n^2)

Space complexity: O(1)

// Author: Huahua, 16 ms, 8.7 MB
class Solution {
public:
  string longestPalindrome(string s) {
    const int n = s.length();
    auto getLen = [&](int l, int r) {
      while (l >= 0 && r < n 
             && s[l] == s[r]) {
        --l;
        ++r;
      }
      return r - l - 1;
    };
    int len = 0;
    int start = 0;
    for (int i = 0; i < n; ++i) {
      int cur = max(getLen(i, i), 
                    getLen(i, i + 1));
      if (cur > len) {
        len = cur;
        start = i - (len - 1) / 2;
      }
    }
    return s.substr(start, len);
  }
};

// Author: Huahua, 6 ms， 36.5 MB
class Solution {
  public String longestPalindrome(String s) {
    int len = 0;
    int start = 0;
    for (int i = 0; i < s.length(); ++i) {
      int cur = Math.max(getLen(s, i, i), 
                         getLen(s, i, i + 1));
      if (cur > len) {
        len = cur;
        start = i - (cur - 1) / 2;
      }
    }
    return s.substring(start, start + len);
  }
  
  private int getLen(String s, int l, int r) {
    while (l >= 0 && r < s.length() 
           && s.charAt(l) == s.charAt(r)) {
      --l;
      ++r;
    }
    return r - l - 1;
  }
}

# Author: Huahua, 812 ms, 12.7MB
class Solution:
  def longestPalindrome(self, s: str) -> str:
    n = len(s)
    def getLen(l, r):
      while l >= 0 and r < n and s[l] == s[r]:
        l -= 1
        r += 1
      return r - l - 1
    
    start = 0
    length = 0    
    for i in range(n):      
      cur = max(getLen(i, i),
                getLen(i, i + 1))
      if cur <= length: continue
      length = cur
      start = i - (cur - 1) // 2
    return s[start : start + length]