zoukankan      html  css  js  c++  java
  • [LeetCode] Longest Palindromic Substring

    This problem has a long story. There are just too many solutions on the web and it can be studied for a long time before you fully grasp it. Morever, it can induce many other concepts or problems (longest palindromic subsequence, longest common substring, etc).

    The simplest way to solve it is to use two-dimensional DP. We denote P[i][j] to be an indicator of whether the substring from i to j (inclusive) is a palindrome. It is obvious that the following relationships hold:

    1. P[i][i] = 1 (each character itself is palindromic);
    2. P[i][i + 1] = s[i] == s[j] (two neighboring characters are palindromic if they are the same);
    3. P[i][j] = P[i + 1][j - 1] && s[i] == s[j] (If the substring is palindrome, then adding the same character at both of its two ends still gives a palindrome).

    1 and 2 are base cases and 3 is the general case.

    Then we will have the following unoptimiezd DP code.

     1     string longestPalindrome(string s) {
     2         int start = 0, len = 1, n = s.length();
     3         bool dp[1000][1000] = {false};
     4         for (int i = 0; i < n; i++)
     5             dp[i][i] = true;
     6         for (int i = 0; i < n - 1; i++) {
     7             dp[i][i + 1] = s[i] == s[i + 1];
     8             if (dp[i][i + 1]) {
     9                 start = i;
    10                 len = 2;
    11             }
    12         }
    13         for (int l = 3; l <= n; l++) {
    14             for (int i = 0; i < n - l + 1; i++) {
    15                 int j = i + l - 1;
    16                 dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j];
    17                 if (dp[i][j]) {
    18                     start = i;
    19                     len = l;
    20                 }
    21             }
    22         }
    23         return s.substr(start, len);
    24     }

    Note that each time when we update dp[i][j], we only need dp[i + 1][j - 1] from the left column, so we can maintain a single variable for it and reduce the space complexity from O(n^2) to O(n). The code now becomes as follows.

     1     string longestPalindrome(string s) {
     2         int start = 0, len = 1, n = s.length();
     3         bool cur[1000] = {false};
     4         bool pre;
     5         cur[0] = true;
     6         for (int j = 1; j < n; j++) {
     7             cur[j] = true;
     8             pre = cur[j - 1];
     9             cur[j - 1] = s[j - 1] == s[j];
    10             if (cur[j - 1] && len < 2) {
    11                 start = j - 1;
    12                 len = 2;
    13             }
    14             for (int i = j - 2; i >= 0; i--) {
    15                 bool temp = cur[i];
    16                 cur[i] = pre && s[i] == s[j];
    17                 if (cur[i] && j - i + 1 > len) {
    18                     start = i;
    19                     len = j - i + 1;
    20                 }
    21                 pre = temp;
    22             }
    23         }
    24         return s.substr(start, len);
    25     }

    We may also traverse the string and expand to left and right from any character to obtain the longest palindrome. The following code should be self-explanatory.

     1     string search(string s, int left, int right) {
     2         int l = left, r = right;
     3         while (l >= 0 && r < s.length() && s[l] == s[r]) {
     4             l--;
     5             r++;
     6         }
     7         return s.substr(l + 1, r - l - 1);
     8     }
     9     
    10     string longestPalindrome(string s) {
    11         string longest = s.substr(0, 1);
    12         for (int i = 0; i < s.length() - 1; i++) {
    13             string tmp1 = search(s, i, i);
    14             string tmp2 = search(s, i, i + 1);
    15             if (tmp1.length() > longest.length()) longest = tmp1;
    16             if (tmp2.length() > longest.length()) longest = tmp2;
    17         }
    18         return longest;
    19     }

    Of course, this problem still has a non-trivial O(n) algorithm, named Manacher's algorithm. This page has a nice explanation for it. The final code is shown below.

     1     string process(string s) {
     2         int n = s.length();
     3         string t(2 * n + 3, '#');
     4         t[0] = '$';
     5         t[2 * n + 2] = '%';
     6         for (int i = 0; i < n; i++)
     7             t[2 * (i + 1)] = s[i];
     8         return t;
     9     }
    10     
    11     string longestPalindrome(string s) {
    12         string t = process(s);
    13         int n = t.length();
    14         int* plen = new int[n]();
    15         int center = 0, right = 0;
    16         for (int i = 1; i < n - 1; i++) {
    17             int i_mirror = 2 * center - i;
    18             plen[i] = right > i ? min(plen[i_mirror], right - i) : 0;
    19             while (t[i + plen[i] + 1] == t[i - plen[i] - 1])
    20                 plen[i]++;
    21             if (i + plen[i] > right) {
    22                 center = i;
    23                 right = i + plen[i];
    24             }
    25         }
    26         int maxlen = 0;
    27         for (int i = 1; i < n - 1; i++) {
    28             if (plen[i] > maxlen) {
    29                 center = i;
    30                 maxlen = plen[i];
    31             }
    32         }
    33         delete[] plen;
    34         return s.substr((center - 1 - maxlen) / 2, maxlen);
    35     }
  • 相关阅读:
    Network Embedding 论文小览
    DLRS(深度学习应用于推荐系统论文汇总--2017年8月整理)
    深度语义匹配模型-DSSM 及其变种
    python 按值排序
    python 日期排序
    推荐领域数据集
    EPS 转 pdf 在线
    梯度下降法的三种形式BGD、SGD以及MBGD
    Daily paper -Science 2006: Experimental Study of Inequality and Unpredictability in an Artificial Cultural Market (探究群体行为对商品销量的影响)
    2017年Nature文章“Millions of online book co-purchases reveal partisan differences in the consumption of science”阅读笔记
  • 原文地址:https://www.cnblogs.com/jcliBlogger/p/4562069.html
Copyright © 2011-2022 走看看