Palindrome partitioning

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.For example, given s = "aab",Return [ ["aa","b"], ["a","a","b"] ]

class Solution {
    vector<vector<string>> retVString;
    bool palin[1500][1500];
public:
    vector<vector<string>> partition(string s) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(s.size() == 0)
            return vector<vector<string>>();
        int leng = s.size();
        for(int i = 0; i < leng; i++)
            for(int j = 0; j < leng; j++)
                palin[i][j] = false;

        for(int i = leng-1; i >= 0; i--){
            for(int j = i; j < leng; j++){
                if(s[i] == s[j] && (j-i<2 || palin[i+1][j-1])){
                    palin[i][j] = true;
                }
            }
        }
        retVString.clear();
        dfs(s, 0, vector<string>());
        return retVString; 
    }
    void dfs (string& s, int start, vector<string> palinStr)
    {
        if(start == s.size())
        {
            retVString.push_back(palinStr);
        }
        for(int i = start; i < s.size(); i++)
        {
            if(palin[start][i])
            {
                palinStr.push_back(s.substr(start, i - start + 1));
                dfs(s, i+1, palinStr);
                palinStr.pop_back();
            }
        }
    }
};

递归的写法问题：

         关于分割问题的dp和递归的写法，有两种：f（start,end）= f(start, k) + f(k+1, end)和f（div）= f(div+1) + XXX。这两种写法看待的子问题不同，第一种是将一个大问题在k处分开，分为两个，对于dp的写法是开一个二维的矩阵，从对角线向右上角移动（习惯），会写3层嵌套循环。第二种写法，也是将一个问题分解为两个字问题，但不同之处在于子问题f（start，div）已经解决，只要解决f（div+1，end）的字问题。这种写法只需2层嵌套循环。这两种看法的递归写法也不同，第二种递归写法方便记录中各种可能解（div == end时），而第一种则没有办法判定可能解是否已得到，需要额外记录。