回文类型题目

下面是一些经常遇到的回文类型题目

1. 验证回文串

题目125. 验证回文串 。 如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

核心：使用队列，左右同时出，如果剩余结果 >=1 就是回文。

func isValidByte(a byte) bool{
    if (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || (a >= '0' && a <='9') {
        return true
    }
    return false
}
func isPalindrome(s string) bool {
    queue := []byte{}
    for i:=0; i<len(s); i++ {
        if isValidByte(s[i]) {
            if s[i] >= 'A' && s[i] <= 'Z' {
                 queue = append(queue, s[i] - 'A' + 'a')
            } else {
                 queue = append(queue, s[i])
            }
           
        }
    }
    for len(queue) > 1 {
        l := queue[0]
        queue = queue[1:]
        r := queue[len(queue)-1]
        queue = queue[:len(queue)-1]
        if l != r {
            return false
        }
    }
    return true
}

2. 最长回文子串

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

这个算法题在面试中经常会遇到，算法核心思想是：利用dp矩阵来实现。

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}
func longestPalindrome(s string) string {
    size := len(s)
    dp := make([][]int, size)
    for i:=0; i<size; i++ {
        dp[i] = make([]int, size)
    }

    maxGain := 0
    left := 0
    right := 0
    for l:=0; l<size; l++ {
        for i:=0; i+l < size; i++ {
            j := i + l
            if l == 0 {
                dp[i][j] = 1
            } else if l == 1 {
                if s[i] == s[j] {
                    dp[i][j] = 1
                }
            } else {
                if (s[i] == s[j]) && (dp[i+1][j-1] == 1) {
                    dp[i][j] = 1
                }
            }

            if dp[i][j] == 1 {
                if maxGain < l {
                    maxGain = l
                    left = i
                    right = j
                }
            }
        }
    }
    return s[left: right+1]
}

相关题目:

• 题目 647. 回文子串个数。 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。 跟上面的算法是一致的。 只是进行数数的操作。

• 题目给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。 子序列不要求是连续的。 leetcode516. 输入：s = "bbbab" 输出：4 . 解释：一个可能的最长回文子序列为 "bbbb" 。
  【关于不连续，其实也容易理解 取了左边 或者 下边的最大值，然后返回右上角的值。】

回文可以不连续。 核心思想还是动态规划标记矩阵。 先绘制中间线，然后第二条，然后不等的时候根据左边 或者 下边的最大值。 否则坐下一格+2.

if(s[i] === s[j]){
    dp[i][j] = dp[i+1][j-1]+2;
}else{
    dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
}
// 返回的值是dp[0][len-1]

• 题目44. 通配符匹配
  通配符匹配 leetcode 44. 给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 ? 和 * 的通配符匹配。 核心方法: 构建dp矩阵[多一个], 然后遇到 * 则从 正下1后全部通吃, ? 则斜下一个1, 如果是字符则去比较，如果相同为1。 是两个for嵌套

这个题目稍微难一点，也是dp矩阵的一个应用。

func isMatch(s string, p string) bool {
    rows , cols := len(p), len(s)
    dp := make([][]int, rows+1)
    for i:=0; i<=rows; i++ {
        dp[i] = make([]int, cols+1)
    }
    dp[0][0] = 1
    for i:=1; i<=rows; i++ {
        if p[i-1] == '*' {
            for j:=0; j<=cols; j++ {
                if dp[i-1][j] == 1 {
                    for ;j<=cols; j++ {
                        dp[i][j] = 1
                    }
                }
            }
        } else if p[i-1] == '?' {
            for j:=1; j<=cols; j++ {
                if dp[i-1][j-1] == 1 {
                    dp[i][j] = 1
                }
            }
        } else {
            for j:=1; j<=cols; j++ {
                if dp[i-1][j-1] == 1 && p[i-1] == s[j-1] {
                    dp[i][j] = 1
                }
            }
        }
    }
    if dp[rows][cols] == 1 {
        return true
    }
    return false
}