Palindrome Partitioning

I： 求全集用DFS 

（参数包括vector<vector<...>>和vector<...>，当满足结束条件就把后者加进前者；注意每次加完元素并DFS下一步结束时删除这次加的一遍继续循环）

class Solution {
public:
    vector<vector<string>> partition(string s) {  
            vector<vector<string>> result;  
            vector<string> output;              
            DFS(s, 0, output, result);  
            return result;  
       }  
       void DFS(string &s, int start, vector<string>& output, vector<vector<string>> &result)  
       {      
            if(start == s.size())  
            {  
                 result.push_back(output);  
                 return;  
            }  
            for(int i = start; i< s.size(); i++)  
            {    
                 if(isPalindrome(s, start, i))  
                {  
                     output.push_back(s.substr(start, i-start+1));  
                     DFS(s, i+1, output, result);  
                     output.pop_back();  
                }  
           }  
      }  
      bool isPalindrome(string &s, int start, int end)  
      {  
           while(start< end)  
           {  
                if(s[start] != s[end])  
                return false;  
                start++; end--;  
           }  
           return true;  
      }
};

II：求最优解用DP 

（res[i]代表切的次数，从后向前；p[i][j]代表是否是回文）

class Solution {
public:    
    int minCut(string s) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int res[s.size()+1];
        bool p[s.size()][s.size()];
        int i,j;
        for (i=0; i<=s.size(); i++) {
            res[i]=s.size()-i;
        }
        for (i=0; i<s.size(); i++) {
            for (j=0; j<s.size(); j++) {
                if (i==j) {
                    p[i][j]=true;
                }else{
                    p[i][j]=false;
                }
            }
        }
        for (i=s.size()-1; i>=0; i--) {
            for (j=i; j<s.size(); j++) {
                
                if (s[i]==s[j] && (j-i<=1 || p[i+1][j-1])) {
                    p[i][j]=true;
                    res[i]=res[i]<(res[j+1]+1)? res[i]:(res[j+1]+1);
                }
            }
        }
        return res[0]-1;
    }
};