leetcode解析回文子串拆分

转载请注明来自souldak，微博:@evagle

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"]

  ]

思路： 假设长度为1,2...i的拆分已经都知道了，用C[i]表示，现在考虑s[i+1]，

1. s[i+1]自己分为一组，C[i+1]中加入C[i]中每一种拆分加上s[i+1]的结果

2. s[i+1]与前k个构成回文，即s[i+1]s[i]...s[i-k+1]是回文，那么C[i+1]加入C[k]中的每种拆分加上s[i+1]s[i]...s[i-k+1]的结果

最终就得到了C[i+1]

举个例子：aab，现在C[0]={{a}}

现在看C[1].分两种情况，s[1]单独一个字符串{a,a}，s[1]和s[0]构成回文{aa}。

C[1]={{a,a},{aa}}

C[2]类似，b自己单独，那就是C[1]中的每个集合加入b,得到{{a,a,b},{aa,b}}

再检测b与前k个字符是否构成回文，发现不能构成回文了，所以最终结果就是{{a,a,b},{aa,b}}

CODE：

 

/**

 * @file Palindrome_Partitioning.cpp

 * @Brief 

 * @author  Brian 

 * @version 1.0

 * @date 2013-09-06

 */



#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <memory.h>

#include <algorithm>

#include <math.h>

#include <queue>

#include <vector>

using namespace std;

 

#define MAXINT 0x7fffffff

 

class Solution {

    public:

        struct Node{

            vector< vector<string> > vstr ;

        };

        vector<vector<string> > partition(string s) {



            int len = s.length();

            Node* nodes  = new Node[len];



            vector<string> str0;

            str0.push_back(s.substr(0,1));

            nodes[0].vstr.push_back(str0);



            for(int i=1;i<len;i++){

                for(int j=0;j<=i;j++){

                    string subs = s.substr(j,i-j+1);

                    if(is_palindrome(subs)){

                        if(j==0){

                            vector<string> tmp;

                            tmp.push_back(subs);

                            nodes[i].vstr.push_back(tmp);

                        }else{

                            for(int k=0;k<nodes[j-1].vstr.size();k++){

                                vector<string> tmp;

                                vector<string> pre = nodes[j-1].vstr[k];

                                for(int p=0;p<pre.size();p++){

                                    tmp.push_back(pre[p]);

                                }

                                tmp.push_back(s.substr(j,i-j+1));

                                nodes[i].vstr.push_back(tmp);  

                            }

                        }

                    }



                }

            }

            return nodes[len-1].vstr;

        }

        bool is_palindrome(string s){

            if(s.length() <= 1)

                return true;

            else{

                for(int i=0;i<s.length()/2;i++){

                    if(s[i]!=s[s.length()-i-1]){

                        return false;

                    }

                }    

            }

            return true;



        }

        void printv (vector<vector<string> > str){

            for(int i=0;i<str.size();i++){

                for(int j=0;j<str[i].size(); j++){

                    cout<<str[i][j]<<"\t";

                }

                cout<<endl;

            }

        }

};

int main(){

    Solution s;

    s.printv(s.partition("a"));

    return 0;

}