《LeetCode之每日一题》:246.分割回文串

题目链接： 分割回文串

有关题目

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。
返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

题解

法一：回溯 + 动态规划
参考官方题解
Tips

void assign( size_type count, const T& value );
	作用：替换容器的内容。
	注：以 count 份 value 的副本替换内容。

class Solution {
private:
    vector<vector<int>> f;//f[i][j]表示在s 下标[i, j]范围内的子串是否为回文串
    vector<vector<string>> ret;//返回值
    vector<string> ans;//存放符合分割条件的字符串
    int n;
public:
    
    void dfs(const string& s, int i)
    {
        //[0, n - 1]都为符合条件的分割字符串
        if (i == n)
        {
            ret.push_back(ans);
            return ;
        }

        //在[0, i - 1]都为符合条件的分割字符串下,找到下一个回文串的边界j
        for (int j = i; j < n; j++)
        {
            if (f[i][j])
            {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                //回撤操作
                ans.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        n = s.size();

        //初始条件
        //i >= j的空串，以及长度为一 的子串都为回文串
        f.assign(n, vector<int>(n, true));

        //预处理回文串,方便回溯过程中O(1)时间内判断s[i, j]是否为回文串
        for (int i = n - 1; i >= 0; i--)
        {
            for (int j = i + 1; j < n; j++)
            {
                f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);

        return ret;
    }
};

法二：回溯 + 记忆化搜索
参考官方题解

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;
    }
};