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

    }

};