[LeetCode 132] - 回文分割II(Palindrome Partitioning II)
前言
在软件开发行业中实际工程做得久了，大多数人会发现很少有机会接触到各种算法。正如Reddit上有人评论到，当初进公司的时候通过了n轮算法面试，实际工作却很可能是不断的解“null pointer exception”的bug。但是算法作为软件开发的基础的重要性确是不容置疑的，由此我最近突然想要练习练习算法题，补充一下工作中接触不到的知识。在探索过程中发现了LeetCode这个网站，其中Online Judge部分有不少不错的练习题，遂打算在博客中分享解题经验。我google了一下目前分享LeetCode的博客，大多全篇代码或比较简单的解题报告。对于经过ACM训练的人可能看到要点就能领悟了，但是对于我这种非ACM人士来说经常看得一头雾水。所以我希望以一个程序员而不是ACM选手的角度分享解题过程，而不是ACM高手那样的精炼提示：“用DP就能搞定”，“是NP问题”。最后，所有的问题的解决方案将会用C++代码实现。
问题
给定一个字符串s，切割s使该切割结果中每一个子串都是一个回文。
返回需要切割次数最少的回文集。
例如，如果有s = "aab",
返回1，因为分割集["aa","b"]可以由s切割一次产生
初始思路
不管用什么方法，一个判断字符串是不是回文的函数肯定是少不了的，这个比较容易实现。我们可以同时从字符串的头部和尾部向中间移动，只要字符有不等的情况发生，那么改字符串肯定不是回文。代码如下：
bool IsPalindrome(const std::string& s, size_t start, size_t end) { bool result = true; while(start < end) { if(s[start] != s[end]) { result = false; break; } ++start; --end; } return result; }
要找出切割次数最少的回文集，那么我们可以找出所有可能的回文集，然后找出切割次数最少的那个。要怎么找出所有的回文集呢？让我们用较短的aab作为例子人力暴力拆解看看：
a,a,b
aa,b
我们从aab的起点开始，先选长度为1的子串，发现它是回文，这样问题分解为求a和[ab的所有回文集合]的组合。然后选取长度为2的子串，也是回文，问题分解为aa和[b的所有回文集合]的组合。最后选取长度问3的子串，发现它不是回文。
用代码模拟一下，大概是这样：
void FindMinPartition(const std::string& s, size_t start) { size_t pos = start; while(pos < s.size()) { if(IsPalindrome(s, start, pos)) { FindMinPartition(s, pos + 1); } ++pos; } }
可以看到函数里面出现了递归，既然是递归就要有递归结束条件。我们可以看看前面模拟的aa和[b的所有回文集合]的情况，判断b的所有回文集时发现b也是回文，但是我们不需要再往后找了，因为再往后就超出了字符串的范围，由此我们可以得到递归的结束条件应该是start >= s.size()(别忘了下标是从0开始的，下标为s.size()的时候已经越界了）。
现在怎么递归清楚了，但是切割次数还没统计呢。不难看出每判断出一个回文，就是一次切割。方便起见，我们可以用一个独立于改函数的全局或成员变量来保存，每次判断出回文后对其加1。且慢，如果光是加1这个切割次数就变成了整个过程的切割次数总和，这个数字肯定不对。让我们在用aab的例子来看看，当我们解决完a和[ab的所有回文集合]的组合的问题后取长度为2的字符串aa时，切割次数应该是1，因为切完a后我们又从头开始切aa，相当于对a的那次切割已经被取消了。从而可以得出每次递归解决问题后切割次数应该减1。
好了，那么现在最后的问题就是算最小切割次数了。每次递归结束时，我们都会得到一个回文集及切割的次数，将其与一个专门存放最小次数的变量比较，如果当前切割次数小于该变量就更新之即可。这里要注意的是我们对最后的一个子串也“切了一刀”，所以和最小次数比较及赋值时要减去1。
最后得出方案：
class Solution32_v1 { public: int minCut(const std::string& s) { minCut_ = -1; currentCut_ = 0; FindMinPartition(s, 0); return minCut_; } private: void FindMinPartition(const std::string& s, size_t start) { if(start < s.size()) { size_t pos = start; while(pos < s.size()) { if(IsPalindrome(s, start, pos)) { ++currentCut_； FindMinPartition(s, pos + 1); --currentCut_; } ++pos; } } else { if(currentCut_ - 1 < minCut_ || minCut_ == -1) { minCut_ = currentCut_ - 1; } } } int minCut_; int currentCut_; };
运行“Judge small”，顺利通过测试！很好，下面让我们运行“Judge Large”。什么，竟然提交失败了，超时！
优化
在本机运行超时的用例：
fifgbeajcacehiicccfecbfhhgfiiecdcjjffbghdidbhbdbfbfjccgbbdcjheccfbhafehieabbdfeigbiaggchaeghaijfbjhi
需要6秒才能返回结果。看来LeetCode不允许这么长的执行时间。要怎么优化呢？
经过观察，可以发现我们在递归的过程中有很多重复运算。以上面的字符串为例，我们会计算[f],[i],[f]与[gbeajcacehiicccfecbfhhgfiiecdcjjffbghdidbhbdbfbfjccgbbdcjheccfbhafehieabbdfeigbiaggchaeghaijfbjhi的所有回文集合]。然后又会计算[fif]与[gbeajcacehiicccfecbfhhgfiiecdcjjffbghdidbhbdbfbfjccgbbdcjheccfbhafehieabbdfeigbiaggchaeghaijfbjhi的所有回文集合]。在有很多递归调用的情况下，这种重复会浪费很多时间。所以我们需要想一个办法重复利用某些计算结果。
首先，要保存已近计算过的分割次数，很自然的想到map。于是我们定义一个std::map<std::string, int>类型的类成员变量来保存某个子串的最小分割次数，该字符串本身作为key。
其次，由于要保存各子串的分割次数，使用一个成员变量不能满足要求，我们需要通过返回值告诉自己的上层函数，并由上层函数计算出最小分割次数。
int partMin = -1; int partCut = 0; 循环start partCut = FindMinPartition(s, pos + 1); if(partCut < partMin || partMin == -1) { partMin = partCut; } 循环end return partMin;
最后，我们需要得到的是某个子串的分割次数而不是当前的分割次数。需要通过partCut - currentCut_计算出来。因为currentCut_为进一步分割子串前的分割次数，而partCut为分割子串后的分割次数，两者的差即为该子串贡献的分割次数。
这样在每次尝试递归求解之前，我们都可以判断一下该子串以前有没有被计算过，如果有，可以直接使用计算结果而避免递归。把所有功能结合起来之后：
class Solution132_v2 { public: Solution132_v2() : currentCut_(0) { } int FindMinPartition(const std::string& s, size_t start) { if(start < s.size()) { int pos = start; int partMin = -1; int partCut = 0; while(pos < s.size()) { if(IsPalindrome(s, start, pos)) { std::string rest = s.substr(pos + 1, s.size() - pos - 1); ++currentCut_; if(rest != "") { std::map<std::string, int>::const_iterator iter = infoMap_.find(rest); if(iter != infoMap_.end()) { if(currentCut_ + iter->second < partMin || partMin == -1) { partMin = currentCut_ + iter->second; } ++pos;
--currentCut_; continue; } } partCut = FindMinPartition(s, pos + 1); if(partCut < partMin || partMin == -1) { partMin = partCut; } if(rest != "") { infoMap_[rest] = partCut - currentCut_; } --currentCut_; } ++pos; } return partMin; } else { return currentCut_ - 1; } } private: int currentCut_; std::map<std::string, int> infoMap_; };
现在在本机处理fifgbeajcacehiicccfecbfhhgfiiecdcjjffbghdidbhbdbfbfjccgbbdcjheccfbhafehieabbdfeigbiaggchaeghaijfbjhi只需要1ms了。提交，运行！这回大多数字符串通过了，但是又挂在了
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
这样一个字符串上。
再次优化
在本机再次运行处理这个超长字符串，用时3.6秒。还能怎么优化呢？由于我们要找的是最小分割次数，是不是能终止一些已经没可能产生最小分割的循环？尝试在判断回文成功后加入下列代码：
int estimate = 0; if(pos == s.size() - 1) { estimate = currentCut_; } else { estimate = currentCut_ + 1; } if(estimate >= partMin && partMin != -1) { break; }
这里注意当当前回文是字符串后半部分时，分割次数是不会增加的（我们在后面返回时会减掉）。而如果不是最后，至少会增加1。如果估计的分割数将会大于等于当前的最小分割数，那么已经没有必要再找下去了。
再次尝试本机运行，用时基本没有变化。这是怎么回事？重新审视我们的分割方法，每次取子串都是从最短的取起，如abba会首先得到[a],[b],[b],[a]的3次分割子集。这就导致了滤条件基本没用，因为首先放进去的都是分割次数最大的。由于子串越长，分割次数肯定更少，我们应该采用先从最长子串取起的方法。还是拿最简单的aab做例子。我们先取长度为3的aab，发现不是回文。再取长度为2的aa，发现是回文，进而求解b的回文集。最后去长度为1的a，进而求解ab的回文集。这样从最长取起的方法就可以有效的利用我们的终止循环条件了。调整后的代码如下：
class Solution132 { public: Solution132() : currentCut_(0) { } int FindMinPartition(const std::string& s, size_t start) { if(start < s.size()) { int pos = s.size() - 1; int partMin = -1; int partCut = 0; while(pos >= (int)start) { if(IsPalindrome(s, start, pos)) { int estimate = 0; if(pos == s.size() - 1) { estimate = currentCut_; } else { estimate = currentCut_ + 1; } if(estimate >= partMin && partMin != -1) { break; } std::string rest = s.substr(pos + 1, s.size() - pos- 1); ++currentCut_; if(rest != "") { std::map<std::string, int>::const_iterator iter = infoMap_.find(rest); if(iter != infoMap_.end()) { //std::cout << "String: " << rest << "-Count: " << iter->second << std::endl; if(currentCut_ + iter->second < partMin || partMin == -1) { partMin = currentCut_ + iter->second; } --pos; --currentCut_; continue; } } partCut = FindMinPartition(s, pos + 1); if(partCut < partMin || partMin == -1) { partMin = partCut; } if(rest != "") { infoMap_[rest] = partCut - currentCut_; } --currentCut_; } --pos; } return partMin; } else { return currentCut_ - 1; } } private: int currentCut_; std::map<std::string, int> infoMap_; };
这回在本机处理那个超长字符串只要7ms了，应该没问题了。提交并运行：
终于成功通过 Judge Large！在这次解题过程中我们可以看到通过一步步的优化，实现同样目的的程序性能可以有数百倍的提高。
