131分割回文串

题目

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

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

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2：

输入：s = “a”
输出：[[“a”]]

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> result;//存储最终的所有结果
        vector<string> path;//存储当前遍历的结果
        dfs(s, path, result, 0);//0表示从0号元素的后面开始砍一刀
        return result;
    }
private:
    void dfs(string &s, vector<string>& path, vector<vector<string>>& result, int start){
    	//如果开始下标等于字符串长度，表示已经找到了一条路径
        if(start == s.size()){
            result.push_back(path);
            return;
        }
        //寻找从start位置开始，在哪些位置砍一刀可以使[start,i]之间的字符串为回文串
        for(int i=start; i<s.size(); ++i){
        	//如果是回文串，将当前字符串加入到路径中
            if(isPalindrome(s, start, i)){
                path.push_back(s.substr(start, i-start+1));
                dfs(s, path, result, i+1);//寻找该路径后续的的回文串
                path.pop_back();//恢复该路径
            }
        }
    }
    //双指针判断是否为回文串
    bool isPalindrome(const string& s, int start, int end){
        while(start<end && s[start]==s[end]){
            ++start;
            --end;
        }
        return start>=end;
    }
};

• 时间复杂度O(2^n)

• 空间复杂度O(n)

• 思路：DFS

  • i表示在i号元素的后面砍一刀
  • for循环表示横向拓展，dfs的递归调用表示纵向拓展
  • 当start等于size时，已经找到了一条路径，此时返回
  • 双指针法判断回文数

• 方法二：动态规划

class Solution {
public:
    vector<vector<string>> partition(string s) {
        int n=s.size();
        vector<vector<string>> result;
        vector<string> path;
        //提前用dp数组存储s[i,j]是否为回文串
        vector<vector<bool>> dp(n,vector<bool>(n,false));
        //填dp数组，分三种情况，只有一个字符，有两个字符，大于两个字符
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if(i==j) dp[i][j]=true;
                else {
                    if(j-i+1==2) dp[i][j]= s[i]==s[j];
                    else dp[i][j]= s[i]==s[j]&&dp[i+1][j-1];
                }
            }
        }
        dfs(0,path,dp,s,result);//dfs搜索，与直接搜索代码一致
        return result;
    }

    void dfs(int start,vector<string> &path,const vector<vector<bool>> &dp,const string &s,vector<vector<string>> &result)
    {
        if(start==s.size())
        {
            result.push_back(path);
            return;
        }

        for(int i=start;i<s.size();i++)
        {
            if(dp[start][i]==true) 
            {
                path.push_back(s.substr(start,i-start+1));
                dfs(i+1,path,dp,s,result);
                path.pop_back();
            }

        }
    }
};

DFS参考详解