编程训练第三十期——分割回文串

编程问题:

给你一个字符串 s,请你将 s 分割成一些子串,使每个子串都是 回文串 。返回 s 所有可能的分割方案。回文串 是正着读和反着读都一样的字符串。


示例:

  • 输入:s = “aab”
    输出:[[“a”,“a”,“b”],[“aa”,“b”]]
  • 输入:s = “a”
    输出:[[“a”]]

解法:

1.回溯+动态规划
由于需要求出字符串 s 的所有分割方案,因此我们考虑使用搜索 + 回溯的方法枚举所有可能的分割方法并进行判断。假设我们当前搜索到字符串的第 i 个字符,且 s[0…i-1] 位置的所有字符已经被分割成若干个回文串,并且分割结果被放入了答案数组 ans 中,那么我们就需要枚举下一个回文串的右边界 j,使得 s[i…j] 是一个回文串。因此,我们可以从 i 开始,从小到大依次枚举 j。对于当前枚举的 j 值,我们使用双指针的方法判断 s[i…j] 是否为回文串:如果 s[i…j] 是回文串,那么就将其加入答案数组 ans 中,并以 j+1 作为新的 i 进行下一层搜索,并在未来的回溯时将 s[i…j] 从 ans 中移除。如果我们已经搜索完了字符串的最后一个字符,那么就找到了一种满足要求的分割方法。

时间复杂度:O(n×2^n ),其中 n 是字符串 s 的长度。在最坏情况下,s 包含 n 个完全相同的字符,因此它的任意一种划分方法都满足要求。而长度为 n 的字符串的划分方案数为 2^(n-1) = O(2^n),每一种划分方法需要 O(n) 的时间求出对应的划分结果并放入答案。尽管动态规划预处理需要 O(n^2)的时间,但在渐进意义下小于 O(n×2^n ),因此可以忽略。
空间复杂度:O(n^2),这里不计算返回答案占用的空间。数组 dp需要使用的空间为 O(n^2),而在回溯的过程中,我们需要使用 O(n) 的栈空间以及 O(n) 的用来存储当前字符串分割方法的空间。由于 O(n) 在渐进意义下小于 O(n^2),因此空间复杂度为 O(n^2)。

class Solution {
private:
    void dfs(string s, int size, vector<vector<bool>>& dp, vector<vector<string>>& res, vector<string>& combine, int index)
    {
        if (index == size)
        {
            res.push_back(combine);
            return;
        }
        for (int j = index; j < size; j++)
        {
            if (dp[index][j])
            {
                combine.push_back(s.substr(index, j - index + 1));
                dfs(s, size, dp, res, combine, j + 1);
                combine.pop_back();
            }
        }
    }

public:
    vector<vector<string>> partition(string s) {
        int size = s.size();
        vector<vector<bool>> dp(size, vector<bool>(size));
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j <= i; j++)
            {
                if (s[i] == s[j] && (i - j < 2 || dp[j+1][i-1]))
                {
                    dp[j][i] = true;
                }
            }
        }
        vector<vector<string>> res;
        vector<string> combine;
        dfs(s, size, dp, res, combine, 0);
        return res;
    }
};

将dp数组计算嵌入dfs

class Solution {
private:
    vector<vector<int>> f;
    vector<vector<string>> ret;
    vector<string> ans;
    int n;

public:
    void dfs(const string& s, int i) {
        if (i == n) {
            ret.push_back(ans);
            return;
        }
        for (int j = i; j < n; ++j) {
            if (isPalindrome(s, i, j) == 1) {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                ans.pop_back();
            }
        }
    }

    // 记忆化搜索中,f[i][j] = 0 表示未搜索,1 表示是回文串,-1 表示不是回文串
    int isPalindrome(const string& s, int i, int j) {
        if (f[i][j]) {
            return f[i][j];
        }
        if (i >= j) {
            return f[i][j] = 1;
        }
        return f[i][j] = (s[i] == s[j] ? isPalindrome(s, i + 1, j - 1) : -1);
    }

    vector<vector<string>> partition(string s) {
        n = s.size();
        f.assign(n, vector<int>(n));

        dfs(s, 0);
        return ret;
    }
};
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值