动态规划算法OJ刷题(3)

news2024/12/24 20:29:03

CC19 分割回文串-ii

问题描述

给出一个字符串s，分割s使得分割出的每一个子串都是回文串。计算将字符串s分割成回文串的最小切割数。例如:给定字符串s=“aab”，返回1，因为回文分割结果[“aa”,“b”]是切割一次生成的。

解题思路

方法1：用一维数组来完成，O(N^3)

注意转移方程必须是让两个相邻状态之间一步完成。

状态方程F(i) : 到第i个字符所需要的最小分割次数
状态转移方程 : j<i && str[j+1, i]是回文串，若F(i)=0【表示从第1个字符到第i个字符是回文串】F(i, j) = min(F(j) + 1)
初始条件 : F(i) = i - 1 ==> F(1) = 0。即单个字符只需要切0次，因为单子符都为回文串，2个字符最大需要1次，3个2次…【因为状态转移方程中要取min，那么F(i)要给一个最大的分割次数i-1】
返回结果 : F(s.size())

此题i = 0是无效状态。

在这里插入图片描述

//时间复杂度O(N^3)
class Solution {
  public:
    /**
     *
     * @param s string字符串
     * @return int整型
     */

    bool isPal(string& str, int start, int end) {
        while (start < end) {
            if (str[start] != str[end]) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }

    int minCut(string s) {
        // write code here
        int len = s.size();
        if (0 == len) return 0;
        
        //先判断整体是不是回文串
        if (isPal(s, 0, len-1)) return 0;

        vector<int> ret(len + 1);
        //初始条件
        for (int i = 1; i <= len; ++i) {
            ret[i] = i - 1;
        }
        //状态转移方程
        for (int i = 2; i <= len; ++i) {
            //先判断整体是不是回文串
            if (isPal(s, 0, i - 1)) {
                ret[i] = 0;
                continue;
            }
            //j<i && str[j, i-1]是回文串
            for (int j = 1; j < i; ++j) {
                if (isPal(s, j, i - 1)) {
                    ret[i] = min(ret[i], ret[j] + 1);
                }
            }
        }
        return ret[len];
    }
};

方法2：用空间换时间，用二维矩阵来保存是否为回文串的状态。时间复杂度O(N^2)

状态方程F(i,j) : 区间[i, j]是否为回文串
状态转移方程 : F(i, j) : s[i]==s[j] && F(i+1, j-1) 【如果字符串的首尾相同，就缩小范围再判断】

需特殊处理：1个字符 i==j，F(i,j): true; 两个字符 i+1=j, F(i,j): s[i] == s[j]
初始条件 : i==j，F(i,j): true
返回结果 : F(s.size())

class Solution {
  public:
    /**
     *
     * @param s string字符串
     * @return int整型
     */

    bool isPal(string& str, int start, int end) {
        while (start < end) {
            if (str[start] != str[end]) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }

    vector<vector<bool>> getMat(string& s) {
        int n = s.size();
        vector<vector<bool>> Mat(n, vector<bool>(n, false));
        for (int i = n - 1; i >= 0; --i) {
            for (int j = i; j < n; j++) {
                if (j == i) Mat[i][j] = true;
                else if (j == i + 1) 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) {
        int len = s.size();
        if (0 == len) return 0;
        //先判断整体是不是回文串
        if (isPal(s, 0, len - 1)) return 0;

        vector<vector<bool>> Mat = getMat(s);
        vector<int> ret(len + 1);
        for (int i = 0; i <= len; ++i) {
            ret[i] = i - 1;
        }

        for (int i = 2; i <= len; ++i) {
            for (int j = 0; j < i; ++j) {
                if (Mat[j][i - 1])
                    ret[i] = min(ret[i], ret[j] + 1);
            }
        }
        return ret[len];
    }
}

给定两个字符串S和T，返回S子序列等于T的不同子序列个数有多少个？字符串的子序列是由原来的字符串删除一些字符（也可以不删除）在不改变相对位置的情况下的剩余字符。例如，"ACE"是"ABCDE"的子序列，但是"AEC"不是；S=“nowcccoder”, T = “nowccoder” ，返回3【now+ccoder/nowc+coder/nowcc+oder】；S=“rabbbit”, T = “rabbit” ，返回3【ra+bbit/rab+bit/rabb+it】；

解题思路

子问题：S的前i个字符构成的子串与T的前j个字符相同的子序列的个数

子串的长度要大于等于T的长度才能找到有相同的子串。

状态方程F(i,j) : S的前i个字符已经与T的前j字符相同了
状态转移方程 :

在F(i,j)处需要考虑S[i] = T[j] 和 S[i] != T[j]两种情况:

当S[i] = T[j]: 1、让S[i]匹配T[j]，则F(i,j) = F(i-1,j-1); 2、让S[i]不匹配T[j], 则问题就变为S[1:i-1]中的子串与T[1:j]相同的个数，则F(i,j) = F(i-1,j) , 故S[i] = T[j]时，F(i,j) = F(i-1,j-1) + F(i-1,j)

当S[i] != T[j]: 问题退化为S[1:i-1]中的子串与T[1:j]相同的个数,故，S[i] != T[j]时，F(i,j) = F(i-1,j)
初始条件 : F(i,0) = 1 —> S的子串与空串相同的个数，只有空串与空串相同
返回结果 : F(S.size(), T.size())

class Solution {
  public:
    /**
     *
     * @param S string字符串
     * @param T string字符串
     * @return int整型
     */
    int numDistinct(string S, string T) {
        // write code here
        int s_size = S.size();
        int t_size = T.size();
        // S的长度小于T长度，不可能含有与T相同的子串
        if (S.size() < T.size()) return 0;
        // T为空串，只有空串与空串相同，S至少有一个子串，它为空串
        if (T.empty()) return 1;
        // F(i,j)，初始化所有的值为0
        vector<vector<int> > f(s_size + 1, vector<int>(t_size + 1, 0));
        // 空串与空串相同的个数为1
        f[0][0] = 1;
        for (int i = 1; i <= s_size; ++i) {
            // F(i,0)初始化
            f[i][0] = 1;
            for (int j = 1; j <= t_size; ++j) {
                // S的第i个字符与T的第j个字符相同
                if (S[i - 1] == T[j - 1]) {
                    f[i][j] = f[i - 1][j] + f[i - 1][j - 1];
                } else {
                    // S的第i个字符与T的第j个字符不相同
                    // 从S的前i-1个字符中找子串，使子串与T的前j个字符相同
                    f[i][j] = f[i - 1][j];
                }
            }
        }
        return f[s_size][t_size];
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/422320.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！