[leetcode]Palindrome Partitioning

思路，思路，还是思路。拿到这道题目的时候，习惯性的用DP去想，想不出，然后想分治，然后想到搜索（遍历），觉得效率太低。但其实看了题解之后，这种求全部解的，用遍历如DFS是很自然的。相比之下，之后的Palindrome Partitioning II那个题目，DP显然更自然。

当理解到是DFS时，这道题忽然就和九度那道数字里添+-（http://ac.jobdu.com/problem.php?pid=1498）算结果的像了，都是在一个字符序列里根据限制加分割的符号。这两道都需要预处理，九度那个预处理算出数字，这道是可以记录s[i,j]之间是不是回文。

参考：http://www.tuicool.com/articles/N3AvEz

public class Solution {
    private ArrayList<ArrayList<String>> ans = new ArrayList<ArrayList<String>>();
    public ArrayList<ArrayList<String>> partition(String s) {
        ans.clear();
        int len = s.length();
        boolean[][] dp = new boolean[len][len];
        ArrayList<Integer> pos = new ArrayList<Integer>(); // the position to split
        pos.add(-1);
        for (int i = 0; i < len; i++)
        {
            for (int j = i; j < len; j++)
            {
                dp[i][j] = true;
                for (int l=i,r=j; l<=r; l++,r--)
                {
                    if (s.charAt(l)!=s.charAt(r)) dp[i][j] = false;
                }
            }
        }
        sub(s, 0, dp, pos);
        return ans;
    }
    private void sub(String s, int depth, boolean[][] dp, ArrayList<Integer> pos)
    {
        if (depth == s.length()-1)
        {
            int last = pos.get(pos.size()-1)+1;
            if (dp[last][depth])
            {
                pos.add(depth);
                ArrayList<String> res = new ArrayList<String>();
                for (int i = 0; i < pos.size()-1; i++)
                {
                    res.add(s.substring(pos.get(i)+1, pos.get(i+1)+1));
                }
                ans.add(res);
                pos.remove(pos.size()-1);
            }
        }
        else
        {
            int last = pos.get(pos.size()-1)+1;
            if (dp[last][depth])
            {
                pos.add(depth);
                sub(s, depth+1, dp, pos);
                pos.remove(pos.size()-1);
            }
            sub(s, depth+1, dp, pos);
        }
    }
}

第二刷，使用函数会简洁很多：

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> result;
        vector<string> part;
        partitionRe(s, 0, result, part);
        return result;
    }
    
    void partitionRe(const string& s, int start, vector<vector<string>>& result, vector<string>& part)
    {
        if (start == s.length())
        {
            result.push_back(part);
            return;
        }
        for (int len = 1; start + len - 1 < s.length(); len++)
        {
            if (!isPalindrom(s, start, start + len))
                continue;
            part.push_back(s.substr(start, len));
            partitionRe(s, start + len, result, part);
            part.pop_back();
        }
    }
    
    bool isPalindrom(const string& s, int start, int end)
    {
        for (int i = 0; start + i < end - i - 1; i++)
        {
            if (s[start + i] != s[end - i - 1])
                return false;
        }
        return true;
    }
};