leetcode—Palindrome 解题报告

1.题目描述

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

也就是给定一个字符串，找出所有可能的划分，每一个划分的每一个字串都是回文串。设这个划分函数为partition_index(string s,int begin,int end)

2.解题思路

蛮力法当然是可以解决这个问题，对于一个长度为n的字符串，有2^n-1种划分方法，只需要判断每种划分是否满足条件即可，虽然不知道暴力法能不能在系统里面ac掉，但是这样显然不是一个正常的程序员该干的事。不过蛮力法会给我们一些启示。我们从为什么蛮力法会有2^n-1种划分方法开始分析。

当然，这也很容易分析，对于长度为n的字符串s₀s₁…s_k…s_n-1,在s_k和s_k-1之间我们可以选择截断与不截断，但是，我们可以基于这个思路理出一个递归的思路，那就是，对于字符串s_begins_begin+1…s_begin+k…s_n-1,所有可能满足条件的划分分为两类：

（1）在s_begin和s_begin+1之间有隔断，这种情况，只需s_begin和partition_index(s,begin+1,n-1)连接起来即可

（2）在s_begin和s_begin+1之间无隔断，这种情况，需找到至少包含s_begin和s_begin+1的一个回文字符串，如果能够找到，比如，s_begin…s_begin+k是一个回文字符串，那么，将这个回文字符串和partition_index(s,k+1,n-1)连接起来，注意，可能找到不止一个包含s₀和s₁的回文字符串，那么有多少个，就多出多少类划分可能；如果找不到，那么返回空vector.

3.代码

#include <iostream>

#include <vector>

#include <string>

#include <iterator>

using namespace std;

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

vector<vector<string> > partition_index(string s, int begin, int end);

bool isPalindrome(string s, int begin,int end);

int main()

{

    partition("cdd");

    return 0;

}

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

    return partition_index(s,0,s.length()-1);

}

vector<vector<string> > partition_index(string s, int begin, int end)

{

    vector<vector<string> > result;

    //边界条件

    if(begin == end)

    {

        vector<string> item;

        item.push_back(s.substr(begin,1));       

        result.push_back(item);

        return result;

    }

    if(begin > end) return result;

    //如果在begin与begin+1之间有划分

    vector<vector<string> > result_part1;

    result_part1 = partition_index(s,begin+1,end);

    if(!result_part1.empty())

    {

        vector<vector<string> >::iterator iter_vv;

        for(iter_vv = result_part1.begin();iter_vv!=result_part1.end();++iter_vv)

        { 

            vector<string> temp;

            //temp = *iter_vv;

            temp.push_back(s.substr(begin,1));

            vector<string>::iterator iter_v;

            for(iter_v = (*iter_vv).begin();iter_v!= (*iter_vv).end();++iter_v)

            {

                temp.push_back(*iter_v);

            }

            result.push_back(temp);

        }

    }

    //如果在begin和begin+1之间无划分

    int nextSeg = begin +1;

    while(nextSeg<=end)

    {

        //找到了回文字符串

        if(isPalindrome(s,begin,nextSeg))

        {

            vector<vector<string> >result_part2_1;

            result_part2_1  = partition_index(s,nextSeg+1,end);

            if(!result_part2_1.empty())

            {

                vector<vector<string> >::iterator iter_vv;

                for(iter_vv = result_part2_1.begin();iter_vv!=result_part2_1.end();++iter_vv)

                {

                    vector<string> temp;

              //      temp = *iter_vv;

                    temp.push_back(s.substr(begin,nextSeg));

                    vector<string>::iterator iter_v;

                    for(iter_v = (*iter_vv).begin();iter_v!= (*iter_vv).end();++iter_v)

                    {

                        temp.push_back(*iter_v);

                    }

                    result.push_back(temp);

                }

            }

            else

            {

                vector<string>temp;

                temp.push_back(s.substr(begin,nextSeg-begin+2));

                result.push_back(temp);

            }

        }

        //继续找看是否有其他的更长的回文字符串

        nextSeg++;

    }

    return result;

}

//判断字符串由begin 和end 确定的字串是否为回文字符串

bool isPalindrome(string s, int begin,int end)

{

    if(begin>end)return false;

    if(begin==end)return true;

    if((begin+1)==end)return s[begin]==s[end];

    else

        if(s[begin]==s[end])

            return isPalindrome(s,begin+1,end-1);

        esle return false;

}

 

另外,代码可以简化,比如,连接结果的代码可以封装成一个函数.