132. Palindrome Partitioning II

最新推荐文章于 2025-09-08 16:25:29 发布

原创最新推荐文章于 2025-09-08 16:25:29 发布 · 103 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 笔记专栏收录该内容

127 篇文章

订阅专栏

本文介绍了一种算法，用于求解给定字符串通过分割形成回文串的最少分割次数。使用动态规划方法，先判断字符串各子串是否为回文，再求解最少分割数。

class Solution {
public:
    int minCut(string s) {
        int n = s.size();

        vector<vector<int> > dp(n, vector<int>(n, 0));

        // len == 1
        for (int i = 0; i < n; ++i) {
            dp[i][i] = 1;
        }

        // len == 2 
        for (int i = 1; i < n; ++i) {
            if(s[i] == s[i - 1])
                dp[i - 1][i] = 1;
        }

        // len >= 3
        for (int len = 3; len <= n; ++len) {
            for (int i = 0; i != n - len + 1; ++i) {
                if (s[i] == s[i + len - 1] && dp[i + 1][i + len - 2] == 1) 
                    dp[i][i + len - 1] = 1;
            }
        }

        // the mincut
        vector<int> min_dp(n, INT_MAX); // with a dummy head
        for (int i = 0; i != n; ++i) {
            if (dp[0][i] == 1) {
                min_dp[i] = 0;
                continue;
            }
            for (int j = 1; j <= i; ++j) {
                if (dp[j][i] == 1) {
                    min_dp[i] = min(min_dp[i], 1 + min_dp[j - 1]);
                }   
            }
        }

        return min_dp[n - 1]; 

    }
};

参考后
在处理第i个的时候可确保i之前（含i）的数据是确定的minCut, i之后的不一定

class Solution {
public:
    int minCut(string s) {
        int n = s.size();


        // the mincut
        vector<int> min_dp(n + 1); // with a dummy head

        min_dp[0] = -1;
        for (int i = 1; i <= n; ++i) 
            min_dp[i] = i - 1;

        for (int i = 0; i != n; ++i) {
            for (int j = 0; i - j >= 0 && i + j < n && s[i - j] == s[i + j]; ++j) {
                min_dp[i + j + 1] = min(min_dp[i + j + 1], min_dp[i - j] + 1);
            }

            for (int j = 0; i - j >= 0 && i + j + 1 < n && s[i - j] == s[i + j + 1]; ++j) {

                min_dp[i + j + 2] = min(min_dp[i + j + 2], min_dp[i - j] + 1);
            }
        }

        return min_dp[n];  
    }
};