[LeetCode] 132. 分割回文串 II

上一个题的变种，改了一下，果然超时，然后在dfs的时候加一些剪枝，仍然超时。。。

因为太晚了，实在不想自己想了，所以看了下题解，果然是要用动态规划来做。

大致思路是k[0][j]表示，当前从0节点出发，到j节点，最少的分隔数。那么得到k[0][j]的递归公式就是 : Min(k[0][t])+1,t取值范围是[0,j)且f[t+1][j]是一个回文串。其实还是蛮简单的

当开始换成dp思路后，就1A了。

class Solution {
    public int minCut(String s) {
        int n = s.length();
        boolean f[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            f[i][i] = true;
        }

        for (int i = 0; i < n; i++) {
            int l = i - 1;
            int r = i + 1;
            while (l >= 0 && r < n) {
                if (s.charAt(l) == s.charAt(r)) {
                    f[l][r] = true;
                } else {
                    break;
                }
                l--;
                r++;
            }

            l = i;
            r = i + 1;
            while (l >= 0 && r < n) {
                if (s.charAt(l) == s.charAt(r)) {
                    f[l][r] = true;
                } else {
                    break;
                }
                l--;
                r++;
            }
        }

        int k[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            k[i][i] = 1;
        }
        int i = 0;
        for (int j = 0; j < n; j++) {
            if (f[i][j]) {
                k[i][j] = 1;
            } else {
                for (int t = 0; t < j; t++) {
                    if (k[i][t] > 0 && f[t + 1][j]) {
                        if (k[i][j] == 0) {
                            k[i][j] = k[i][t] + 1;
                        } else {
                            k[i][j] = Math.min(k[i][j], k[i][t] + 1);
                        }
                    }
                }
            }
        }

        return k[0][n - 1] - 1;
    }
}