leetcode之最长回文子串

题目描述

给你一个字符串 s，找到 s 中最长的回文子串。

---

概念

1. 子串：子串是指原字符串中某一 连续 的序列。
2. 回文子串： 指从左往右读和从右往左读都相同的字符串，在直观上具有轴对称的特性。
3. 子序列： 原始字符串的一个序列，不一定连续。

---

题解

• 方法一： 动态规划

  1. 我们用 S(i,j) 表示从i到j的字符串，考虑一种情形，字符串cbabc为回文串，那么在此字符串的两端加上一个相同的字符a之后，acbabca 也应当为回文串。那状态转移方程为：
     P(i,j) = P(i+1,j-1)&&($S_i$ == $S_j$)。
  2. 以上讨论的情形为字符串长度>2的情况，需要注意一下边界条件，当字符串长度为1时，它是一个回文串，当字符串长度为2时，且两个字符一致时，也应该为一个回文串。
  3. 最终答案为P(i,j)中 j-i+1 最长的即为本题的答案。

     public class Solution
     {
         public string LongestPalindrome(string s)
         {
             int length = s.Length;
             // 边界条件
             if (length < 2)
             {
                 return s;
             }
     
             // 初始化dp数组
             bool[,] dp = new bool[length, length];
             for (int i = 0; i < length; i++)
             {
                  // 长度为1的均为回文串
                 dp[i, i] = true;
             }
     
             int begin = 0, maxLength = 1;
     
             // 枚举的字符串长度
             for (int L = 2; L <= length; L++)
             {
                 // 字符串左边界
                 for (int i = 0; i < length; i++)
                 {
                     // 字符串右边界
                     int j = i + L - 1;
     
                     // 边界条件
                     if (j >= length)
                     {
                         break;
                     }
     
                     if (s[i] != s[j])
                     {
                         dp[i, j] = false;
                     }
                     else
                     {
                         if (j - i + 1 < 3)
                         {
                             dp[i, j] = true;
                         }
                         else
                         {
                             dp[i, j] = dp[i + 1, j - 1];
                         }
                     }
     
                     if (dp[i, j] && j - i + 1 > maxLength)
                     {
                         begin = i;
                         maxLength = j - i + 1;
                     }
                 }
             }
     
             return s.Substring(begin, maxLength);
         }
     }
     

---

• 方法二： 中心扩展算法
  1. 此方法的本质是，从回文中心向外扩展，直到遇到不能扩展的情况为止（遇到边界或者扩展的字符不相同）。
  2. 从每一种边界条件开始扩展，找出最大的回文串即为本题的答案。

     public class Solution
     {
         public string LongestPalindrome(string s)
         {
             if (s == "" || s.Length < 1)
             {
                 return s;
             }
     
             int start = 0, maxLength = 0;
             for (int i = 0; i < s.Length; i++)
             {
                 // 长度为1的边界条件
                 int length1 = ExpandStr(s, i, i);
                 // 长度为2的边界条件
                 int length2 = ExpandStr(s, i, i + 1);
     
                 int curMaxLength = Math.Max(length1, length2);
     
                 if (curMaxLength > maxLength)
                 {
                     start = i - (curMaxLength - 1) / 2;
                     maxLength = curMaxLength;
                 }
             }
     
             return s.Substring(start, maxLength);
         }
     
         private int ExpandStr(string s, int left, int right)
         {
             while (left >= 0 && right < s.Length && s[left] == s[right])
             {
                 left--;
                 right++;
             }
     
             return right - left - 1;
         }
     }