LeetCode回文相关

最新推荐文章于 2022-07-22 08:57:26 发布

zhengbq_seu

最新推荐文章于 2022-07-22 08:57:26 发布

阅读量665

点赞数

分类专栏： LeetCode 文章标签：回文编程

本文链接：https://blog.csdn.net/zhengbq_seu/article/details/88885235

版权

LeetCode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

680. 验证回文字符串 Ⅱ（可以删除一个字符）

方法一：遇到不对劲直接删除然后再对比

131. 分割回文串

方法一：递归（重要）

647. 回文子串（获取所有的子串）

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被计为是不同的子串。

示例 1:

输入: "abc"
输出: 3
解释: 三个回文子串: "a", "b", "c".

示例 2:

输入: "aaa"
输出: 6
说明: 6个回文子串: "a", "a", "a", "aa", "aa", "aaa".

—————————————————————————————————

方法一：奇数和偶数拓展

对每个数进行基于 i 的奇数回文拓展和基于i 和 i + 1 的偶数回文拓展

class Solution {
public:
    int countSubstrings(string s) {
        if (s.empty()) return 0;
        int n = s.size(), res = 0;
        for (int i = 0; i < n; ++i) {
            helper(s, i, i, res);
            helper(s, i, i + 1, res);
        }
        return res;
    }
    void helper(string s, int i, int j, int& res) {
        while (i >= 0 && j < s.size() && s[i] == s[j]) {
            --i; ++j; ++res;
        }
    }
};

方法二：（动态规划）（重要）

i 和 j 的遍历方式是由 dp[ i + 1 ][ j - 1 ] 决定的。dp[ i ][ j ]表示字符串i到j是回文串。

已知 j >= i ;

当j = i时， (s[i] == s[j]）判断足够。

当 j= i + 1时， (s[i] == s[j]）判断足够。

当 j= i + 2时， (s[i] == s[j]）判断足够。

当 j= i + 3及更大的数时， (s[i] == s[j]）判断之上还要加上中间部分是回文的判断。

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size(), res = 0;
        vector<vector<bool>> dp(n, vector<bool>(n, false));
        for (int i = n - 1; i >= 0; --i) {
            for (int j = i; j < n; ++j) {
                dp[i][j] = (s[i] == s[j]) && (j - i <= 2 || dp[i + 1][j - 1]);
                if (dp[i][j]) ++res;
            }
        }
        return res;
    }
};

——————————————————————————————————

5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

—————————————————————————————————

方法一：拓展然后更新最长的数

对每个数进行基于 i 的奇数回文拓展和基于i 和 i + 1 的偶数回文拓展

然后更新当前的最长数目。

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.size() < 2) return s;
        int n = s.size(), maxLen = 0, start = 0;
        for (int i = 0; i < n - 1; ++i) {
            searchPalindrome(s, i, i, start, maxLen);
            searchPalindrome(s, i, i + 1, start, maxLen);
        }
        return s.substr(start, maxLen);
    }
    void searchPalindrome(string s, int left, int right, int& start, int& maxLen) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left; ++right;
        }
        if (maxLen < right - left - 1) {
            start = left + 1;
            maxLen = right - left - 1;
        }
    }
};

————————————————————————————————

680. 验证回文字符串 Ⅱ（可以删除一个字符）

示例 2:

输入: "abca"
输出: True
解释: 你可以删除c字符。

————————————————————————————————

方法：遇到不对劲直接删除然后再对比

这里我出了一个错可见另一篇博客

实际的做法很简单删除再判断就OK了。

class Solution {
public:
    bool validPalindrome(string s) {
        int left = 0, right = s.size() - 1;
        while (left < right) {
            if (s[left] != s[right]) return isValid(s, left, right - 1) || isValid(s, left + 1, right);
            ++left; --right;
        }
        return true;
    }
    bool isValid(string s, int left, int right) {
        while (left < right) {
            if (s[left] != s[right]) return false;
            ++left; --right;
        }
        return true;
    }
};

—————————————————————————————————

131. 分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

———————————————————————————————

方法一：递归（重要）

递归的方法，其中判断是否是回文可以用函数单独实现这里用动态规划实现起来快了很多但是好麻烦哦所以简单的方法在下面我也记录了一下

class Solution {
public:
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<string>> res;
        vector<string> out;
        vector<vector<bool>> dp(n, vector<bool>(n));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= i; ++j) {
                if (s[i] == s[j] && (i - j <= 2 || dp[j + 1][i - 1])) {
                    dp[j][i] = true;
                }
            }
        }
        helper(s, 0, dp, out, res);
        return res;
    }
    void helper(string s, int start, vector<vector<bool>>& dp, vector<string>& out, vector<vector<string>>& res) {
        if (start == s.size()) { res.push_back(out); return; }
        for (int i = start; i < s.size(); ++i) {
            if (!dp[start][i]) continue;
            out.push_back(s.substr(start, i - start + 1));
            helper(s, i + 1, dp, out, res);
            out.pop_back();
        }
    }
};

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> res;
        vector<string> out;
        helper(s, 0, out, res);
        return res;
    }
    void helper(string s, int start, vector<string>& out, vector<vector<string>>& res) {
        if (start == s.size()) { res.push_back(out); return; }
        for (int i = start; i < s.size(); ++i) {
            if (!isPalindrome(s, start, i)) continue;
            out.push_back(s.substr(start, i - start + 1));
            helper(s, i + 1, out, res);
            out.pop_back();
        }
    }
    bool isPalindrome(string s, int start, int end) {
        while (start < end) {
            if (s[start] != s[end]) return false;
            ++start; --end;
        }
        return true;
    }
};

方法二：不用递归，使用循环（重要）

建立了一个三维数组的res，这里的res数组其实也可以看作是一个dp数组，其中 res[i] 表示前 i 个字符组成的子串，即范围 [0, i+1] 内的子串的所有拆分方法，那么最终只要返回 res[n] 极为所求。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<vector<string>>> res(n + 1);
        res[0].push_back({});
        vector<vector<bool>> dp(n, vector<bool>(n));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= i; ++j) {
                if (s[i] == s[j] && (i - j <= 2 || dp[j + 1][i - 1])) {
                    dp[j][i] = true;
                    string cur = s.substr(j, i - j + 1);
                    for (auto list : res[j]) { 这里对于res[j]的所有子串
                        list.push_back(cur); 都添加cur
                        res[i + 1].push_back(list);然后添加到res[i+1]里面
                    }
                }
            }
        }
        return res[n];
    }
};

zhengbq_seu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode回文相关

目录647. 回文子串（获取所有的子串）方法一：奇数和偶数拓展方法二：（动态规划）（重要）5. 最长回文子串方法一：拓展然后更新最长的数680. 验证回文字符串 Ⅱ（可以删除一个字符）方法一：遇到不对劲直接删除然后再对比131. 分割回文串方法一：递归（重要）647. 回文子串（获取所有的子串）给定一个字符串，你的任务是计算这个字符串中有多少...
复制链接

扫一扫