[LeetCode]132. Palindrome Partitioning II

最新推荐文章于 2022-10-15 22:31:15 发布

原创最新推荐文章于 2022-10-15 22:31:15 发布 · 377 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

184 篇文章

订阅专栏

本文详细解析了LeetCode 132题“Palindrome Partitioning II”的解题思路及动态规划算法实现，介绍了如何优化算法以降低时间复杂度。

[LeetCode]132. Palindrome Partitioning II

题目描述

这里写图片描述

思路

动态规划
开始考虑，和单词划分很像
但是简单的遍历加计算是否回文串总共需要n^3的时间复杂度
优化：
先用动归判断字符串中的任一子串是否是回文串，这一过程可以在n^2时间复杂度完成，之后保存状态数组
之后动归来判断需要最少划分是多少，时间复杂度为n^2，在数组中查找是否回文串时间复杂度为常数
终极优化：
综合一起考虑
先初始化状态数组，每一位分别保存到当前位置的字符串需要切割的次数，初始化为当前字符串个数减一，之后进行遍历，对于第i位的字符，内层循环判断从i-j到i+j是否为回文串，如果是的话，那么dp[i + j + 1]位置的状态可以更新，注意在判断时需要考虑回文串是奇数个字符的回文串还是偶数个字符的回文串

代码

注释部分为自己写的优化部分
非注释部分是参考答案的最终优化

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
/*
public:
    void getPalinSubstr(string s) {
        isPalin.resize(s.size(), vector<int>(s.size()));
        for (int i = s.size() - 1; i >= 0; --i) {
            for (int j = i; j < s.size(); ++j) {
                if (i == j)
                    isPalin[i][j] = 1;
                else if (j == i + 1)
                    isPalin[i][j] = s[i] == s[j];
                else
                    isPalin[i][j] = s[i] == s[j] && isPalin[i + 1][j - 1];
            }
        }
    }
    int minCut(string s) {
        getPalinSubstr(s);
        vector<int> res(s.size());

        for (int i = 0; i < s.size(); ++i) {
            if (isPalin[0][i] == 1) {
                res[i] = 0;
            }
            else {
                res[i] = res[i - 1] + 1;
                for (int j = 0; j < i; ++j) {
                    if (isPalin[j + 1][i] == 1)
                        res[i] = min(res[i], res[j] + 1);
                }
            }
        }

        return res[s.size() - 1];
    }
private:
    vector<vector<int>> isPalin;
*/
public:
    int minCut(string s) {
        vector<int> dp(s.size() + 1);
        for (int i = 0; i <= s.size(); ++i)
            dp[i] = i - 1;
        for (int i = 1; i <= s.size(); ++i) {
            for (int j = 0; i - j >= 0 && i + j < s.size() && s[i - j] == s[i + j]; ++j)
                dp[i + j + 1] = min(dp[i + j + 1], 1 + dp[i - j]);
            for (int j = 0; i - j - 1 >= 0 && i + j < s.size() && s[i - j - 1] == s[i + j]; ++j)
                dp[i + j + 1] = min(dp[i + j + 1], 1 + dp[i - j - 1]);
        }
        return dp[s.size()];
    }

};

int main() {
    Solution s;
    cout << s.minCut("aab") << endl;

    system("pause");
    return 0;
}