LeetCode005 Longest Palindromic Substring

最新推荐文章于 2024-09-14 18:52:56 发布
最新推荐文章于 2024-09-14 18:52:56 发布
阅读量191 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxwtry/article/details/66478564
版权
详细见：leetcode.com/problems/longest-palindromic-substring/

说明： manacher

Java Solution: github

package leetcode;

/*
 * 	假定存在唯一一个最长子序列
 */
public class P005_LongestPalindromicSubstring {
	public static void main(String[] args) {
		System.out.println(new Solution4().longestPalindrome("abad"));
	}
	/*
	 * 	毫无疑问manacher(不会拼错了吧)
	 * 	35.45%
	 * 	特别慢
	 * 	57ms
	 */
	static class Solution {
		private final char sign = '#';
	    public String longestPalindrome(String s) {
	    	if (s == null || s.length() == 0)
	    		return "";
	        char[] m = new char[(s.length() << 1) + 1];
	        for (int i = 0; i != m.length; i ++)
	        	m[i] = (i & 0x1) == 0 ? sign : s.charAt(i >>> 1);
	        int[] r = new int[m.length];
	        r[0] = 0; r[1] = 1;
	        int maxr = 2, core = 1, maxindex = 1;
	        for (int i = 2; i != m.length; i ++) {
	        	if (i >= maxr) {
	        		int newr = 1;
	        		while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
	        			newr ++;
	        		r[i] = newr - 1;
	        		maxr = i + r[i];
	        		core = i;
	        	} else {
	        		int j = (core << 1) - i;
	        		if (r[j] + i < maxr) {
	        			r[i] = r[j];
	        		} else {
	        			int newr = 1;
	        			while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
		        			newr ++;
	        			r[i] = newr - 1;
	        			maxr = i + r[i];
	        			core = i;
	        		}
	        	}
	        	if (r[maxindex] < r[i])
	        		maxindex = i;
	        	if (maxr == m.length)
	        		break;
	        }
	        StringBuilder st = new StringBuilder();
	        for (int i = maxindex - r[maxindex]; i != maxindex + r[maxindex] + 1; i ++)
	        	if ((i & 0x1) == 1)
	        		st.append(m[i]);
	        return st.toString();
	    }
	}
	/*
	 * 	没有使用StringBuilder
	 * 	40.94%
	 * 	43 ms
	 */
	static class Solution2 {
		private final char sign = '#';
	    public String longestPalindrome(String s) {
	    	if (s == null || s.length() == 0)
	    		return "";
	        char[] m = new char[(s.length() << 1) + 1];
	        for (int i = 0; i != m.length; i ++)
	        	m[i] = (i & 0x1) == 0 ? sign : s.charAt(i >>> 1);
	        int[] r = new int[m.length];
	        r[0] = 0; r[1] = 1;
	        int maxr = 2, core = 1, maxindex = 1;
	        for (int i = 2; i != m.length; i ++) {
	        	if (i >= maxr) {
	        		int newr = 1;
	        		while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
	        			newr ++;
	        		r[i] = newr - 1;
	        		maxr = i + r[i];
	        		core = i;
	        	} else {
	        		int j = (core << 1) - i;
	        		if (r[j] + i < maxr) {
	        			r[i] = r[j];
	        		} else {
	        			int newr = 1;
	        			while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
		        			newr ++;
	        			r[i] = newr - 1;
	        			maxr = i + r[i];
	        			core = i;
	        		}
	        	}
	        	if (r[maxindex] < r[i])
	        		maxindex = i;
	        	if (maxr == m.length)
	        		break;
	        }
	        int len = m[maxindex] == sign ?  ( (r[maxindex] + 1) >>> 1 ) << 1 : ( ( r[maxindex] >>> 1) << 1 ) + 1;
	        char[] ans = new char[len];
	        int j = 0;
	        for (int i = maxindex - r[maxindex]; i != maxindex + r[maxindex] + 1; i ++)
	        	if ((i & 0x1) == 1)
	        		ans[j ++] = m[i];
	        return new String(ans);
	    }
	}
	/*
	 * 	不用m　char 数组
	 * 	75ms
	 * 	27.05% 
	 */
	static class Solution3 {
		private final char sign = '#';
	    public String longestPalindrome(String s) {
	    	if (s == null || s.length() == 0)
	    		return "";
	        int len = (s.length() << 1) + 1;
	        int[] r = new int[len];
	        r[0] = 0; r[1] = 1;
	        int maxr = 2, core = 1, maxindex = 1;
	        for (int i = 2; i != len; i ++) {
	        	if (i >= maxr) {
	        		int newr = 1;
	        		while (i > newr - 1 && i + newr < len && getIndexOfM(s, i + newr) == getIndexOfM(s, i - newr))
	        			newr ++;
	        		r[i] = newr - 1;
	        		maxr = i + r[i];
	        		core = i;
	        	} else {
	        		int j = (core << 1) - i;
	        		if (r[j] + i < maxr) {
	        			r[i] = r[j];
	        		} else {
	        			int newr = 1;
	        			while (i > newr - 1 && i + newr < len && getIndexOfM(s, i + newr) == getIndexOfM(s, i - newr))
		        			newr ++;
	        			r[i] = newr - 1;
	        			maxr = i + r[i];
	        			core = i;
	        		}
	        	}
	        	if (r[maxindex] < r[i])
	        		maxindex = i;
	        	if (maxr == len)
	        		break;
	        }
	        len = getIndexOfM(s, maxindex) == sign ?  ( (r[maxindex] + 1) >>> 1 ) << 1 : ( ( r[maxindex] >>> 1) << 1 ) + 1;
	        char[] ans = new char[len];
	        int j = 0;
	        for (int i = maxindex - r[maxindex]; i != maxindex + r[maxindex] + 1; i ++)
	        	if ((i & 0x1) == 1)
	        		ans[j ++] = getIndexOfM(s, i);
	        return new String(ans);
	    }
	    char getIndexOfM(String s, int i) {
	    	if ((i & 0x1) == 0)
	    		return sign;
	    	else
	    		return s.charAt(i >>> 1);
	    }
	}
	/*
	 * 	41 ms
	 * 	42.07%
	 */
	static class Solution4 {
		private final char sign = '#';
	    public String longestPalindrome(String s) {
	    	if (s == null || s.length() == 0)
	    		return "";
	        char[] m = new char[(s.length() << 1) + 1];
	        for (int i = 0; i != m.length; i ++)
	        	m[i] = (i & 0x1) == 0 ? sign : s.charAt(i >>> 1);
	        int[] r = new int[m.length];
	        r[0] = 0; r[1] = 1;
	        int maxr = 2, core = 1, maxindex = 1;
	        for (int i = 2; i != m.length; i ++) {
	        	if (i >= maxr) {
	        		int newr = 1;
	        		while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
	        			newr ++;
	        		r[i] = newr - 1;
	        		maxr = i + r[i];
	        		core = i;
	        	} else {
	        		int j = (core << 1) - i;
	        		if (r[j] + i < maxr) {
	        			r[i] = r[j];
	        		} else {
	        			int newr = 1;
	        			while (i > newr - 1 && i + newr < m.length && m[i + newr] == m[i - newr])
		        			newr ++;
	        			r[i] = newr - 1;
	        			maxr = i + r[i];
	        			core = i;
	        		}
	        	}
	        	if (r[maxindex] < r[i])
	        		maxindex = i;
	        	if (maxr == m.length)
	        		break;
	        }
	        return s.substring((maxindex - r[maxindex]) >>> 1, (maxindex + r[maxindex]) >>> 1);
	    }
	}
}


C Solution: github

/*
    url: leetcode.com/problems/longest-palindromic-substring/
    85ms 42.99%
*/



#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char _access_char_array(char* s, int i) {
    if (i % 2 == 0) return '\0';
    return *(s + i / 2);
}

char* longestPalindrome(char* s) {
    int n = strlen(s);
    int ma_n = 2 * n + 1;
    int ma_i = 0;
    int ma_li = 0;
    int ma_mi = 0;
    int ma_mt = 0;
    int l = 0, r = 0, i = 0, j = 0;
    int * ma_r = NULL;
    int ma_an = 0;
    char * answer = NULL;

    //manacher
    ma_r = (int *) malloc(sizeof(int) * ma_n);
    for (ma_i = 0; ma_i < ma_n; ma_i ++)
        *(ma_r + ma_i) = 0;
    for (ma_i = 0; ma_i < ma_n; ma_i ++) {
        if (ma_mt >= ma_n - 1) break;
        ma_mi = 2 * ma_li - ma_i;
        if (ma_i >= ma_mt || (ma_i + *(ma_r + ma_mi) == ma_mt)) {
            l = ma_i;
            r = ma_i;
            while ((l - 1) > -1 && (r + 1) < ma_n && _access_char_array(s, l - 1) == _access_char_array(s, r + 1)) {
                l --;
                r ++;
            }
            *(ma_r + ma_i) = (r - l) / 2;
            ma_an = *(ma_r + ma_an) > *(ma_r + ma_i) ? ma_an : ma_i;
            ma_li = ma_i;
        } else if (ma_i <= ma_mt) {
            *(ma_r + ma_i) = ma_mt - ma_i;
        } else {
            *(ma_r + ma_i) = *(ma_r + ma_mi);
        }
    }
    answer = (char *) malloc(sizeof(char) * (* (ma_r + ma_an) + 1));
    *(answer + *(ma_r + ma_an)) = '\0';
    l = ma_an - *(ma_r + ma_an);
    r = ma_an + *(ma_r + ma_an);
    for (i = l; i <= r; i ++) {
        if (i % 2 == 1)
            *(answer + (j ++)) = _access_char_array(s, i);
    }
    free(ma_r);
    return answer;

}

int main() {
    char* s = "cbbd";
    char* a = longestPalindrome(s);
    unsigned int i = 0;
    printf("len(a) is %d\r\n", strlen(a));
    for (i = 0; i < strlen(a); i ++)
        printf("%c", *(a + i));
    printf("\r\n");
    free(a);
    return 0;
}


Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/longest-palindromic-substring/
    manacher
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年3月26日
    @details:    Solution: AC 632ms 41.14%
'''

class Solution(object):
    def accessString(self, s, index):
        if index % 2 == 0: return '#'
        else: return s[index // 2]
        
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        s_len = 0 if s == None else len(s)
        if s_len == 0: return ""
        m = [0] * (2 * s_len + 1)
        m_last_i, m_mirror_r, m_max_touch_i, m_max_r_index = 0, 0, 0, 0
        for i in range(2 * s_len + 1):
            if m_max_touch_i >= 2 * s_len: break
            m_mirror_r = m[2 * m_last_i - i]
            if i >= m_max_touch_i or i + m_mirror_r == m_max_touch_i:
                left, right = i, i
                while left - 1 > -1 and right + 1 < 2 * s_len + 1 and \
                    self.accessString(s, left - 1) == self.accessString(s, right + 1):
                    left, right = (left - 1), (right + 1)
                m[i] = (right - left) // 2
                if m[m_max_r_index] < m[i]:m_max_r_index = i
                m_last_i = i
                m_max_touch_i = right
            elif i + m_mirror_r < m_max_touch_i:
                m[i] = m[2 * m_last_i - i]
            else:
                m[i] = m_max_touch_i - i
        i = m_max_r_index // 2 - m[m_max_r_index] // 2
        return s[i : i + m[m_max_r_index]]

if __name__ == "__main__":
    s1="tabatabag"
    s = Solution()
    print("answer is \"%s\"" % s.longestPalindrome(s1))







zxwtry
关注
专栏目录
LeetCode 5. Longest Palindromic Substring (最长回文子串)
amoscykl的博客
09-05 411
题目描述： 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。   示例1： 输入: "babad" 输出: "bab" 注意: "aba"也是一个有效答案。 示例2： 输入: "cbbd" 输出: "bb"   Accepted C++ Solution:   1. 改进的中心扩展方法： 将原字符串扩展成#a#b#c#的形式可以直接...
Leetcode 005 Longest Palindromic Substring
Gongzq5的博客
07-27 186
Leetcode 005 Longest Palindromic Substring 题目 Solution 分析 Leetcode 005 Longest Palindromic Substring 找到一个字符串中最长的回文串 题目 Given a string s, find the longest palindromic substring in s. ...
leetcode 005 Longest Palindromic Substring
一个学渣的博客
10-05 216
先贴个代码，这是leetcode提交答案里最快的代码了，膜拜膜拜。public class Solution { char[] ss; int left=0, max=1; public String longestPalindrome(String s) { ss=s.toCharArray(); if(ss.length<1) retur
LeetCode 005 Longest Palindromic Substring
Eminem1147的博客
02-18 131
Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.Example:Input: "babad" Output: "bab" Note: "aba" is also a valid answer.  Example:I...
Leetcode 005 Longest Palindromic Substring （Manachar）
不慌不忙、不急不躁
06-06 156
题目连接：Leetcode 005 Longest Palindromic Substring 解题思路：裸的Manachar 算法，找到最大值后反推子串位置。class Solution { public: string longestPalindrome(string s) { const int maxn = 2 * 1e3 + 5; int pos, rad[maxn];...
LeetCode 5. Longest Palindromic Substring
qq_31361913的博客
07-19 206
第 1 步：定义状态 dp[i][j] 表示子串 s[i..j] 是否为回文子串，这里子串 s[i..j] 定义为左闭右闭区间，可以取到 s[i] 和 s[j]。 第 2 步：思考状态转移方程 在这一步分类讨论（根据头尾字符是否相等），根据上面的分析得到： dp[i][j] = (s[i] == s[j]) and dp[i + 1][j - 1] 说明：「动态规划」事实上是在填一张二维表格，由于构成子串，因此 i 和 j 的关系是 i <= j ，因此，只需要填这张表格对角线以上的部分。看到 dp
【LeetCode】Longest Palindromic Substring【Python || C++】双语言实现
小欧欧的博客
11-04 329
题目（来自leetcode网站）： 题目的意思是把 输入的整数倒叙输出，不改变符号，且需要对整数的范围进行判断； Given a 32-bit signed integer, reverse digits of an integer. Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321 E...
leetcode005 Longest Palindromic Substring
jnuyanfa的博客
03-14 296
题目 5. Longest Palindromic SubstringGiven a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic su
[LeetCode ]Longest Palindromic Substring
GYH0730的博客
11-15 250
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. E...
LeetCode5 Longest Palindromic Substring
01-09
Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000. Java AC 版本
java-leetcode题解之005-Longest-Palindromic-Substring
08-31
java入门 java_leetcode题解之005_Longest_Palindromic_Substring
Leetcode 0005: Longest Palindromic Substring
weixin_43946031的博客
02-13 235
题目描述： Given a string s, return the longest palindromic substring in s. Example 1: Input: s = “babad” Output: “bab” Note: “aba” is also a valid answer. Example 2: Input: s = “cbbd” Output: “bb” Example 3: Input: s = “a” Output: “a” Example 4: Input
[ LeetCode ] 5. Longest Palindromic Substring (C++ & Python)
xn's blog
02-19 364
题目： 5. Longest Palindromic Substring 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" No...
【数据结构与算法 | 灵神题单 | 删除链表篇】力扣2487, 237
2301_80912559的博客
09-09 844
每个节点的值都是 1 ，所以没有需要移除的节点。需要移除的节点是 5 ，2 和 3。移除每个右侧有一个更大数值的节点。- 节点 13 在节点 5 右侧。- 节点 13 在节点 2 右侧。- 节点 8 在节点 3 右侧。给你一个链表的头节点。返回修改后链表的头节点。
LeetCode 2181.合并零之间的节点
weixin_50878507的博客
09-09 550
给你一个链表的头节点head，该链表包含由0分隔开的一连串整数。链表的和的节点都满足。对于每两个相邻的0，请你将它们之间的所有节点合并成一个节点，其值是所有已合并节点的值之和。然后将所有0移除，修改后的链表不应该含有任何0。返回修改后链表的头节点head。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 488
【代码】【JavaScript】LeetCode：707设计链表。
Leetcode Hot 100刷题记录 -Day16（旋转图像）
weixin_45864705的博客
09-14 181
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。请你将图像顺时针旋转 90 度。
leetcode-647. 回文子串
曼巴的博客
09-12 382
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
LeetCode题目难度与数据结构分类指南
- 5题：如 `Longest Palindromic Substring`，涉及字符串复杂性分析和动态规划（DP）。 - 14题：如 `Roman to Integer` 和 `Letter Combinations of a Phone Number`，涉及数学转换和深度优先搜索（DFS）。 4. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值