leetCode131(动态规划+回溯)

今天刷动态规划模块时，刷到一道很有意思的题，这道题主要解法是回溯，但是可以先用动态规划进行预处理来优化

---

题目如下

这道题目我们初看可能并没有啥思路，但是如果我们模拟去分割的时候，我们可以发现，整个过程可以抽象成一棵树
例如对aab进行分割

整体思路为

当我们分割的时候我们要判断割出来的是不是回文串，若不是，这种情况我们就应该舍弃，不能再继续。若是回文子串，我们将进行下一此切割

所以其实这就是一个通过dfs实现的回溯算法。但是，我们还能在判断回文串上进行优化。假设在长度为n的字符串上。我们要判断字串s(i,j)是否为回文，设f(i,j)表示i到j的字串是否回文，则有三种情况；

1. if i==j then f(i,j) = true;
2. if i==j-1 then f(i,j) = (s[i]==s[j]);
3. else f(i,j) = f(i+1,j-1) && (s[i]==s[j]);

代码如下

class Solution {
public:
    vector<vector<string>> res;
    vector<string> tmp;

    //利用动态规划预处理判断回文子串
    void retackle(const string &s, vector<vector<int>> &memo){
        int n = s.size();
        for(int len = 1; len<=n; len++){
            for(int i=0;i<=n-len;i++){
                if(len==1){
                    memo[i][i]=1;
                }else if(len==2){
                    memo[i][i+len-1] = (s[i]==s[i+len-1]);
                }else{
                    memo[i][i+len-1] = (s[i]==s[i+len-1]) && memo[i+1][i+len-2];
                }
            }
        }        
    }
    //回溯算法
    void backtracking(const string &s, int inx, vector<vector<int>> &memo){
        if(inx>=s.size()){
            res.push_back(tmp);
            return;
        }
        for(int i=inx; i<s.size();i++){
            if(memo[inx][i]){
                string str = s.substr(inx, i-inx+1);
                tmp.push_back(str);
                backtracking(s, i+1, memo);
                tmp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<int>> memo(n, vector<int>(n,0));
        retackle(s, memo);
        backtracking(s, 0, memo);
        return res;
    }
};

---

总结
在做题时。我们一定要在纸上将整个解题步骤自己模拟一下。这样我们才能发现其中规律，特别是回溯算法的题时，往往我们画这颗回溯树的时候，就能发现它的规律。