My code:

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<List<String>> partition(String s) {
        ArrayList<List<String>> ret = new ArrayList<List<String>>();
        if (s == null || s.length() == 0)
            return ret;
        ArrayList<String> slide = new ArrayList<String>();
        helper(s, 0, s.length() - 1, ret, slide);
        return ret;
    }
    
    private void helper(String s, int begin, int end,
            ArrayList<List<String>> ret, ArrayList<String> slide) {
        if (begin > end) {
            ret.add(new ArrayList<String>(slide));
            return;
        }
        else if (begin == end) {
            slide.add(s.substring(begin, end + 1));
            ret.add(new ArrayList<String>(slide));
            slide.remove(slide.size() - 1);
            return;
        }
        
        for (int len = 1; len <= end - begin + 1; len++) {
            String tmp = s.substring(begin, begin + len);
            if (!isPalindrome(tmp))
                continue;
            slide.add(tmp);
            helper(s, begin + len, end, ret, slide);
            slide.remove(slide.size() - 1);
        }
        
    }
    
    private boolean isPalindrome(String tmp) {
        if (tmp == null)
            return false;
        else if (tmp.length() == 0 || tmp.length() == 1)
            return true;
        for (int i = 0; i < tmp.length(); i++) {
            if (tmp.charAt(i) != tmp.charAt(tmp.length() - i - 1))
                return false;
        }
        return true;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        System.out.println(test.partition("bb"));
    }
}

状态不是很好，这种题目跑了两次才AC
感觉学长说的很对。hard题目不用很会做。但是medium和easy题目必须给一道题目，立刻就能做出来，在白板上写出来。思路要很清晰，考点要很清楚。
刷题还是很重要的。

**
总结： DFS
**

Anyway, Good luck, Richardo!

都不记得自己做了这道题目。。。
一开始看到以为要用DP。
傻逼啊！！
记住了，只有涉及到求，极值的时候，才需要考虑使用DP。
或者就是模式匹配。
反正，一开始都先想办法用 brute force 做出来。

My code:

public class Solution {
    public List<List<String>> partition(String s) {
        ArrayList<List<String>> ret = new ArrayList<List<String>>();
        
        if (s == null || s.length() == 0) {
            return ret;
        }
        
        helper(0, s, ret, new ArrayList<String>());
        return ret;
    }
    
    private void helper(int begin, String s, List<List<String>> ret, List<String> group) {
        if (begin >= s.length()) {
            ret.add(new ArrayList<String>(group));
        }
        else {
            for (int i = begin + 1; i <= s.length(); i++) {
                String temp = s.substring(begin, i);
                if (!isPalindrome(temp)) {
                    continue;
                }
                else {
                    group.add(temp);
                    helper(i, s, ret, group);
                    group.remove(group.size() - 1);                    
                }
            }
        }
    }
    
    private boolean isPalindrome(String s) {
        if (s == null || s.length() == 0) {
            return true;
        }
        int begin = 0;
        int end = s.length() - 1;
        while (begin < end) {
            if (s.charAt(begin) != s.charAt(end)) {
                return false;
            }
            else {
                begin++;
                end--;
            }
        }
        return true;
    }
}

然后现在想下，是可以优化这个算法的。
怎么优化，也就是设计一个cache
cache[i][j] = true 表示 从 [i, j] 段是回文，就不用再算一遍了。这样应该可以加快速度。

Anyway, Good luck, Richardo! — 08/20/2016