关于前端:JS动态规划计算最长回文子串

作为一个前端算法真的很个别，看了他人的计算方法要不是java c++ 要不就是形容算法看起来很吃力。
于是用 js 重写了一个办法，并且在过程中增加了具体的正文。

const s = 'abcd123dcbaaba11'

function lp(s) {
    let lplang = 1 // 最长长度
    let start = 0 // 当最长长度更新时同时缓存起始点
    
    let len = s.length
    
    let dp = [] // 缓存后果
    
    // 长度 1 2 独自解决
    for(let i=0; i<len; i++) {
        if(dp[i] === undefined) {
            dp[i] = [] // 初始化二维数组
        }
        
        dp[i][i] = true // 本人是本人的回文
        
        // 找出长度为2的回文
        if(s[i] === s[i+1]) {
            dp[i][i+1] = true // 缓存后果
            start = i
            lplang = 2 // 比方两个间断的 aa 也是回文，并且标记最长长度
        }
    }
    
    // 动静布局 找最优子，比方 aa 是回文，那么 baab 只须要判断 b === b && （aa: 缓存的后果）
    // L 为子串长度，首先找出长度为3的回文，而后是4，5...
    // 同时通过 L 计算 子串起点 i+L-1，起始点+长度-1 = 起点
    for(let L=3; L<len; L++) {
        for(let i=0; i+L-1<len; i++) {

            let j = i+L-1 // 第一次比照的是 s[0] === s[2]
            if(s[i] === s[j] && dp[i+1][j-1]) {
                // 中间相等 并且 子是回文
                dp[i][j] = true // 缓存后果 先缓存的是所有的最短的子串后果
                start = i
                lplang = L // 因为L是从小到大便当的 所以前面的回文长度就是最长的
            }
        }
    }
    
    
    return s.substr(start,lplang)
    
}