leetCode解題記錄5 - 最長迴文子串（JS, TS, PY版）

時間  2020-04-09
標籤 leetcode 解題 記錄 最長 迴文 子串 欄目 應用數學 简体版
原文   原文鏈接

5. 最長迴文子串

  • 做者：陳大魚頭
  • github： KRISACHAN
  • 介紹：本倉庫用於記錄魚頭LeetCode解題，主要用Python3, JavaScript與TypeScript實現。

題目描述：

給定一個字符串 s，找到 s 中最長的迴文子串。你能夠假設 s 的最大長度爲 1000。javascript

示例 1:java

// 輸入: "babad"
// 輸出: "bab"
// 注意: "aba" 也是一個有效答案。
複製代碼

示例 2:git

// 輸入: "cbbd"
// 輸出: "bb"
複製代碼

解題思路

解法1 - 中心拓展法

因爲迴文字符串的對稱性，因此每次能夠選擇一個數字做爲中心，進行左右拓展來判斷是不是迴文串。 因爲字符串有可能爲奇數，有可能爲偶數，因此須要從 1 or 2個字符之間開始拓展。 意思就是有 i + i - 1個拓展中心。 則 i 爲奇數位， i + 1爲偶數位。 以此爲理論依據每次循環往兩邊拓展便可。 此解法時間複雜度是O(n^2)。 空間複雜度是O(1)。github

解法2 - 馬拉車算法

第一次接觸這個算法，可是想出這個算法的人，確實牛逼。 馬拉車算法將時間複雜度提高到了線性。 此算法最初遍歷字符，在每一個字符兩邊都插入一個特殊符號，爲避免越界，首尾加上特殊標籤，例如： aabbcbbaa -> ^#a#a#b#b#c#b#b#a#a#$ 保證當前字符串必定爲奇數。 而後左右擴展。 利用一個長度爲原字符串長度的數組arr來保存中心擴展的最大個數。 (arr每一個元素的下標 - arr[i]) / 2 就是原字符串的字符的下標。 咱們設C爲字符串中心，R爲字符串右邊的長度，則有R = C + arr[i]。 這時候就能夠用中心擴展法去求。 咱們用j表示第i個字符與C對應的下標。 但有如下三種狀況會致使arr[j]不正確算法

  1. 長度超出了Rtypescript

  2. arr[j]到了原字符串的左邊界c#

  3. 當i就是爲R時數組

因此遇到以上三種狀況，咱們須要利用中心拓展法去作邊界處理。微信

JS版

/** * @param {string} str * @param {number} left * @param {number} right * @return {number} */
const expandCenter = (str, left, right) => {
    while (left >= 0 && right < str.length && str[left] === str[right]) {
        left--
        right++
    }
    return str.slice(left + 1, right)
}
/** * @param {string} s * @return {string} */
const longestPalindrome1 = (s) => {
    if (!s || !s.length) {
        return ''
    }
    let result = ''
    for (let i = 0; i < s.length; i++) {
        const odd = expandCenter(s, i, i)
        const even = expandCenter(s, i, i + 1)
        if (odd.length > result.length) {
            result = odd
        }
        if (even.length > result.length) {
            result = even
        }
    }
    return result
}

/** * @param {string} s * @return {string} */
const setTarget = (s) => {
    if (!s) {
        return ''
    }
    if (s.length === 0) {
        return '^$'
    }
    let res = '^'
    for (let i = 0, len = s.length; i < len; ++i) {
        res = res + '#' + s.charAt(i)
    }
    res += '#$'
    return res
}

/** * @param {string} s * @return {string} */
const longestPalindrome2 = (s) => {
    let str = setTarget(s)
    let len = str.length
    let arr = new Array(len)
    let C = 0 // 右邊界最大的迴文子串的中心
    let R = 0 // 子串右邊界
    for (let i = 1; i < len - 1; ++i) {
        let j = 2 * C - i
        if (R > i) {
            arr[i] = Math.min(R - i, arr[j]) // 右邊界處理
        } else {
            arr[i] = 0
        }

        // 遇到上述三種特殊狀況時，使用中心拓展法
        while (str[i + 1 + arr[i]] === str[i - 1 - arr[i]]) {
            arr[i]++
        }

        // 判斷是否須要更新R的值
        if (i + arr[i] + R) {
            C = i
            R = i + arr[i]
        }
    }
    let maxLen = 0 // 最大長度
    let index = 0 // 中心下標
    for (let i = 1; i < len - 1; ++i) {
        if (arr[i] > maxLen) {
            maxLen = arr[i]
            index = i
        }
    }
    let start = (index - maxLen) / 2
    return s.substring(start, start + maxLen)
}
複製代碼

TS版

/** * @解法1 * @思路 * 因爲迴文字符串的對稱性，因此每次能夠選擇一個數字做爲中心，進行左右拓展來判斷是不是迴文串。 * 因爲字符串有可能爲奇數，有可能爲偶數，因此須要從 1 or 2個字符之間開始拓展。 * 意思就是有 i + i - 1個拓展中心。 * 並且 i 爲奇數位 * i + 1爲偶數位 * 以此爲理論依據每次循環往兩邊拓展便可。 * * 此方式時間複雜度是O(n^2) */

/** * @param {string} str * @param {number} left * @param {number} right * @return {number} */
const expandCenter = (str: string, left: number, right: number): string => {
    while (left >= 0 && right < str.length && str[left] === str[right]) {
        left--
        right++
    }
    return str.slice(left + 1, right)
}
/** * @param {string} s * @return {string} */
const longestPalindrome1 = (s: string): string => {
    if (!s || !s.length) {
        return ''
    }
    let result: string = ''
    for (let i: number = 0; i < s.length; i++) {
        const odd: string = expandCenter(s, i, i)
        const even: string = expandCenter(s, i, i + 1)
        if (odd.length > result.length) {
            result = odd
        }
        if (even.length > result.length) {
            result = even
        }
    }
    return result
}


const setTarget = (s: string): string => {
    if (!s) {
        return ''
    }
    if (s.length === 0) {
        return '^$'
    }
    let res: string = '^'
    for (let i: number = 0, len = s.length; i < len; ++i) {
        res = res + '#' + s.charAt(i)
    }
    res += '#$'
    return res
}

const longestPalindrome2 = (s: string): string => {
    let str: string = setTarget(s)
    let len: number = str.length
    let arr: number[] = new Array(len)
    let C: number = 0 // 右邊界最大的迴文子串的中心
    let R: number = 0 // 子串右邊界
    for (let i: number = 1; i < len - 1; ++i) {
        let j: number = 2 * C - i
        if (R > i) {
            arr[i] = Math.min(R - i, arr[j]) // 右邊界處理
        } else {
            arr[i] = 0
        }

        // 遇到上述三種特殊狀況時，使用中心拓展法
        while (str[i + 1 + arr[i]] == str[i - 1 - arr[i]]) {
            arr[i]++
        }

        // 判斷是否須要更新R的值
        if (i + arr[i] + R) {
            C = i
            R = i + arr[i]
        }
    }
    let maxLen: number = 0 // 最大長度
    let index: number = 0 // 中心下標
    for (let i: number = 1; i < len - 1; ++i) {
        if (arr[i] > maxLen) {
            maxLen = arr[i]
            index = i
        }
    }
    let start: number = (index - maxLen) / 2
    return s.substring(start, start + maxLen)
}
複製代碼

PY版

from typing import List
import math

def expandCenter(s: str, left: int, right: int) -> str:
    while left >= 0 and right < len(s) and s[left] == s[right]:
        left -= 1
        right += 1
    return s[left + 1: right]


def longestPalindrome1(s: str) -> str:
    if not(s) or not(len(s)):
        return ''
    result: str = ''
    for i in range(len(s)):
        odd: str = expandCenter(s, i, i)
        even: str = expandCenter(s, i, i + 1)
        if len(odd) > len(result):
            result = odd
        if len(even) > len(result):
            result = even
    return result

def setTarget(s: str) -> str:
    if not(s):
        return ''
    if (len(s) == 0):
        return '^$'
    res: str = '^'
    for i in range(len(s)):
        res += '#'
        res += s[i]
    res += '#$'
    return res


def longestPalindrome2(s: str) -> str:
    newStr: str = setTarget(s)
    l: int = len(newStr)
    arr = [0 for _ in range(l)]
    C: int = 0
    R: int = 0
    for i in range(l - 1):
        j: int = 2 * C - i
        if R > i:
            arr[i] = min(R - i, arr[j])
        else:
            arr[i] = 0
        while newStr[i + 1 + arr[i]] == newStr[i - 1 - arr[i]]:
            arr[i] += 1
        if i + arr[i] + R:
            C = i
            R = i + arr[i]
    maxLen: int = 0
    idx: int = 0
    for i in range(1, l - 1):
        if arr[i] > maxLen:
            maxLen = int(arr[i])
            idx = i
    start: int = int((idx - maxLen) / 2)
    return s[start:start + maxLen]
複製代碼

若是你喜歡探討技術，或者對本文有任何的意見或建議，很是歡迎加魚頭微信好友一塊兒探討，固然，魚頭也很是但願能跟你一塊兒聊生活，聊愛好，談天說地。 魚頭的微信號是：krisChans95 也能夠掃碼關注公衆號，訂閱更多精彩內容。 ui

https://fish-pond-1253945200.cos.ap-guangzhou.myqcloud.com/img/base/qrcode-all.png
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程