dp刷题（二）分割回文串（详细推导+O(N^3)=＞O(N^2)优化）

曾几何时`

已于 2023-01-07 23:51:27 修改

阅读量551

点赞数

分类专栏：笔试题动态规划 # 动态规划文章标签：算法

于 2023-01-07 19:42:14 首次发布

本文链接：https://blog.csdn.net/weixin_66151870/article/details/128594030

版权

笔试题同时被 3 个专栏收录

41 篇文章 1 订阅

订阅专栏

动态规划

16 篇文章 0 订阅

订阅专栏

动态规划

14 篇文章 0 订阅

订阅专栏

状态F(i)：即为第i个字符时所需要切割的最小次数

状态转移方程：F(i) = min(F(i), F(j)+1)

优化：

注意点

分割回文串-ii_牛客题霸_牛客网

描述

给出一个字符串s，分割s使得分割出的每一个子串都是回文串

计算将字符串s分割成回文分割结果的最小切割数

例如:给定字符串s="aab",

返回1，因为回文分割结果["aa","b"]是切割一次生成的。

示例1

输入："aab"

返回值：1

思路

首先明确我们需要返回切割字符串的最小次数，那么定义一个

状态F(i)：即为第i个字符时所需要切割的最小次数

当i指向3时，如何判断它的分割次数呢，那我得需要重新定义一个指针j从i前面开始遍历

当j指向1位置时，后续AB不为回文，当j指向2时，后续字符B为回文，

即需要给2位置后进行一次分割

即就完成了F(3)的最小分割划分，即F(3)=F(2)+1那么这个3 和 2分别对于i与j的话

状态转移方程：F(i) = F(j)+1

我们继续进行划分：当i指向4时，j从1开始，发现ABA为一个回文串，即F(4)=F(1)+1 = 1；

当j指向2位置时，后续BA不为一个回文

当j指向3位置时，后续A为一个回文即F(4) = F(3)+1 = 2;

那么F(4)的值应该为多少呢？肯定是更小的1；

所以我们在状态转移时需要进行就小选取，不断更新F(i)

状态转移方程：F(i) = min(F(i), F(j)+1)

我们继续划分：当i指向5位置时，j从1开始，发现后续不为回文

当j指向2位置时，后续不为回文

当j指向3时，后续AA为一个回文F(5) = F(3)+1 = 2

当j指向4时，后续A为一个回文 F(5) = F(4)+1 = 2

我们发现 F(5)最小值为2，结果就是2嘛？

我的AABAA一个整体都是回文，所以在j进行遍历之前首先判断1~i 是否为回文

        int minCut(string s) {
        // write code here
        int len = s.size();
        if(s.empty() || isPal(s, 0, len-1))
            return 0;
        vector<int> dp(len+1);
        for(int i = 1; i <= len; i++)
            dp[i] = i-1;
        for(int i = 2; i <= len; i++)
        {
            // 首先判断1~i是否回文
            if(isPal(s, 0, i-1))
            {
                dp[i] = 0;
                continue;
            }
            for(int j = 1; j < i; ++j)
            {
                // 再【j, i】满足回文条件下进行更新dp
                if(isPal(s, j, i-1))
                {
                    //状态转移方程：F(i) = min(F(i), F(j)+1)
                    dp[i] = min(dp[i], dp[j]+1);
                }
            }
        }
        return dp[len];
        }
           
        // 回文判断函数
        bool isPal(string s, int begin, int end)
        {
            while(begin < end)
            {
            if(s[begin]!=s[end])
            return false;
            begin++;
            end--;
            }
            return true;
        }

优化：

下图中在时间复杂度为O(N^2)的双重for循环嵌套内部中又多了一个判断回文字符串的函数，该函数内部时间复杂度为O(N),所以整个函数运行时的时间复杂度为O(N^3)

如何进行优化呢，如果能够去掉if判断内部函数，可以直接访问字符串关于回文方面的信息，那么时间复杂度就由O(N^3)降为O(N^2)

用一个二维矩阵存放这个字符串中的每个字符串之间关于回文串的信息。

注意点

① 定义bool类型的n*n的矩阵，以矩阵类型返回，在mincut函数内部定义二维数组进行接受

② 推出来的状态转移方程：由俩边向内层进行转移，所以需要访问到内部Mat矩阵的（i+1,j-1）位置元素，所以在是从一个半三角而且是从下至上进行建立

    vector<vector<bool>> GetMat(string s)
    {
        int len = s.size();
        vector<vector<bool>> Mat(len, vector<bool> (len, false));
        for(int i = len-1; i >=0; i--)
        {
            for(int j = i; j < len; j++)
            {
                if(i==j)
                    Mat[i][j] = true;
                else if(i+1 == j)
                    Mat[i][j] = (s[i]==s[j]);
                else
                    Mat[i][j] = s[i]==s[j]&&Mat[i+1][j-1];
            }
        }
        return Mat;
    }

整体使用：


class Solution {
public:
    /**
     * 
     * @param s string字符串 
     * @return int整型
     */
    // bool isPal(string s, int begin, int end)
    // {
    //     while(begin < end)
    //     {
    //         if(s[begin]!=s[end])
    //         return false;
    //         begin++;
    //         end--;
    //     }
    //     return true;
    // }
    vector<vector<bool>> GetMat(string s)
    {
        int len = s.size();
        vector<vector<bool>> Mat(len, vector<bool> (len, false));
        for(int i = len-1; i >=0; i--)
        {
            for(int j = i; j < len; j++)
            {
                if(i==j)
                    Mat[i][j] = true;
                else if(i+1 == j)
                    Mat[i][j] = (s[i]==s[j]);
                else
                    Mat[i][j] = s[i]==s[j]&&Mat[i+1][j-1];
            }
        }
        return Mat;
    }
    
    int minCut(string s) {
        // write code here
        int len = s.size();
        if(s.empty())
        return 0;
        vector<int> dp(len+1);
        for(int i = 1; i <= len; i++)
            dp[i] = i-1;
        vector<vector<bool>> Mat = GetMat(s);
        for(int i = 2; i <= len; i++)
        {
            if(Mat[0][i-1])
            {
                dp[i] = 0;
                continue;
            }
            for(int j = 1; j < i; ++j)
            {
                if(Mat[j][i-1])
                {
                    dp[i] = min(dp[i], dp[j]+1);
                }
            }
        }
        return dp[len];
    }
};