DP Palindrome Partitioning II-优快云博客

本文探讨了一个经典的回文划分问题，通过深度优先搜索（DFS）和动态规划（DP）两种方法来寻找将字符串分割成最少数量回文子串的方法。文章详细介绍了每种方法的实现细节，并比较了它们的时间复杂度。

思想：

方法一：DFS 。TLE

刚开始照办了上一题的思路，但是递归层次太深，导致TLE，毕竟时间复杂度是O(2^N)级别。

这是TLE的代码：

class Solution {
private:
    int min_cut;
    int cur_cut;
    bool isPalindrome(const string& s, int start, int end) {
        while(start < end && s[start] == s[end]) {
            ++start;
            --end;
        }
        return start >= end;
    }
    void dfs(const string& s, int start) {
        if(start == s.size()) {
            min_cut = min(min_cut, cur_cut);
            return;
        }
        for(int i = start; i < s.size(); ++i) {
            if(isPalindrome(s, start, i)) {
                ++cur_cut;
                dfs(s, i+1);
                --cur_cut;
            }
        }
    }
public:
    int minCut(string s) {
        min_cut = INT_MAX;
        cur_cut = 0;
        dfs(s, 0);
        return min_cut - 1;
    }
};

看Discuss用DP来做。

DP。时间复杂度O(N^2)，空间复杂度O(N^2)。

两组状态向量；

f[i] : 代表i到n-1的最小cut数；

p[i][j] : 代表i到j是否是回文串；

f[i]初始值为每一个字母后切一刀的情况，状态转移方程为：

f[i] = min(f[i], f[j+1] + 1); 其中，i<=j<=n-1

p[i][j]的递归方程为：

p[i][i] = true;

p[i][j] = true if s[i] == s[j] && p[i+1][j-1] == true

class Solution {
public:
    int minCut(string s) {
        const int n = static_cast<int>(s.size());
        vector<int> f(n+1, 0);
        vector<vector<bool>> p(n, vector<bool>(n, false));
        for(int i = 0; i <= n; ++i) {
            f[i] = n - 1 -i;
        }
        for(int i = n - 1; i >= 0; --i) {
            for(int j = i; j < n; ++j) {
                if(s[i] == s[j] && (j - i < 2 || p[i+1][j-1])) {
                    p[i][j] = true;
                    f[i] = min(f[i], f[j+1] + 1);
                }
            }
        }
        return f[0];
    }
};