LeetCode Palindrome Partitioning

 1 class Solution {

 2 public:

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

 4         int len = s.length();

 5         vector<vector<string> >* memo = new vector<vector<string> >[len + 1];

 6         vector<vector<string> > ret;

 7         

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

 9             int sub_len = 0;

10             vector<vector<string> >& cur = memo[i];

11             

12             for (int j=i-1; j>=0; j--) {

13                 string sub = s.substr(j, ++sub_len);

14                 

15                 int p=0, q = sub_len - 1; 

16                 for (; p < q; p++, q--) {

17                     if (sub[p] != sub[q]) break;

18                 }

19                 if (p < q) continue; 

20                 

21                 if (j == 0) {

22                     cur.push_back(vector<string>(1, sub));

23                     continue;

24                 }

25                 

26                 for (int k=0; k<memo[j].size(); k++) {

27                     cur.push_back(memo[j][k]);

28                     cur.back().push_back(sub);

29                 }

30             }

31         }

32         ret = memo[len];

33         delete[] memo;

34         return ret;

35     }

36 };

明显感觉可以用DFS进行搜索，但是觉得单纯用dfs的话会有许都状态被重复计算，于是转变思路改用“dp”（也不知道这个是不是算dp），按字符串的长短把每个可能的状态先计算好，提交一次通过，但是时间150+ms，这有点不正常，通常leetcode上的题目时间一般在100-ms，所以翻查了一下网上资料，有的直接使用了dfs，把代码一跑居然只要50+ms，于是自己再写个dfs，的确是只要用这个时间。回过来看，可能是第一种方法在计算各个状态的时候用了太多的vector.push_back操作占用了较多的时间和空间。下面给出dfs代码

 1 class Solution {

 2 private:

 3     vector<vector<string> > ret;

 4 public:

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

 6         ret.clear();

 7         vector<string> m;

 8         dfs(m, s, 0, s.length() - 1);

 9         return ret;

10     }

11 

12     void dfs(vector<string>& m, string& str, int s, int e) {

13         if (s > e) {

14             ret.push_back(m);

15         }

16         for (int i=s; i<=e; i++) {

17             if (!is_palindrome(str, s, i)) continue;

18             m.push_back(str.substr(s, i - s + 1));

19             dfs(m, str, i+1, e);

20             m.pop_back();

21         }

22     }

23 

24 

25     bool is_palindrome(string& s, int i, int j) {

26         while (i < j) {

27             if (s[i++] != s[j--]) return false;

28         }

29         return true;

30     }

31 };

 参考：

zhuli哥的题解：http://www.cnblogs.com/zhuli19901106/p/3570430.html