Palindrome Partitioning(DFS)

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 {
    public:
        vector<vector<string> > ans_m;
        vector<string> ans_v;
        
        bool IsPalindrome(const string & s){
            int i = 0; 
            int j = s.size() -1;
            //这里之前有一个bug,while(i != j) 比如 bb的情况，一下子 i = 1, j = 0, 然后就会越界访问 core dump
            while(i < j){
                if (s.at(i) == s.at(j)){
                    i++;
                    j--;
                }else{
                    return false;
                }
            }
            return true;
        }
        //这里dfs的意思是说从start的位置出发，找最近的回文串，然后继续递归
        // abbab-> 'a' 'b' 'b' 'a' 'b' path  OK
        // abbab-> 'a' 'b'             退栈直到 path
        // abbab-> 'a' 'b'  'bab'      path  OK
        // abbab-> 'a' 'bb' 'a' 'b'    path  OK
        // abbab-> ''                  path --> 一直退栈
        // abbab-> 'abba' 'b'          path  OK
        
        //如果是显式的给出图
        /*                  root
                         /         \
                           a           abba
                      /  \            \
                     b   'bb'          'b'
                    /  \    \           \
                   b   'bab' 'a'         OK
                  /       \    \
                 a         OK   'b'
                /                 \
               b                   OK
              /
             OK
            
            一目了然，你可以理解为图的DFS，也可以理解为树的DFS，Path就是记录路径的。
            因为本质是一棵树，不会重复访问，也不需要VISIT数组
            for循环本质是判断当前节点下有多少领接的边
            
            以后对于这种题目，先写出表达式tree或者graph，然后再去遍历
        */
        void dfs(string s, int start, vector<string> & path){
            if (start == s.size()){
                ans_m.push_back(path); //搜索退出的条件 搜到整个字符串完成为止
                return;
            }
            for(int i = start + 1; i <= s.size(); i++){ //确定当前start位置出发的回文串
                string sub_s = s.substr(start,i - start);
                if (IsPalindrome(sub_s)){
                    path.push_back(sub_s);
                    dfs(s,i,path);
                    path.resize(path.size() -1);
                }
            }
        }
        vector<vector<string> > partition(string s) {
            ans_m.clear();
            ans_v.clear();
            dfs(s,0,ans_v);
            return ans_m;                 
        }
};v