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;
}

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