Leet Palindrome Partitioning II

class Solution {
public:
    int minCut(string s) {
        int len = s.length();
        int*  p_dp = new int[len + 1];
        char* s_dp = new char[len * len];
        int*  mm = new int[len + 1];
        mm[0] = 0;
        memset(s_dp, -1, len * len);
        memset(p_dp, 0, (len + 1) * sizeof(int));

        int ret;
        for (int i=1; i<=len; i++) {
            int sub_len = i;
            int minc = INT_MAX;

            for (int j=0; j<=i-1; j++, sub_len--) {

                char* p_is = &s_dp[j * len + i-1];
                char b = 0;
                if (sub_len >= 3 && -1 != (b = s_dp[(j+1) * len + i - 2])) {
                    *p_is = b && (s[j] == s[j + sub_len - 1]);
                }
                if (*p_is == -1) {
                    int p = j, q = j + sub_len - 1;
                    for (; p < q && s[p] == s[q]; p++, q--);
                    *p_is = (p < q) ? 0 : 1;
                }
                if (*p_is == 0) continue;
                if (p_dp[j] < minc) minc = p_dp[j];
                if (minc == mm[j]) break;
            }
            p_dp [i] = minc + 1;
            mm[i] = p_dp[i];
            for (int k = i-1; k >=0 && mm[k]>mm[k+1]; k--) {
                mm[k] = mm[k+1];
            }
        }
        ret = p_dp[len];
        delete[] mm;
        delete[] p_dp;
        delete[] s_dp;
        return ret - 1;
    }
};

原来想着既然前一题中已经想到了类似dp的方法，这一题应该更简单才是，不过。。。不过。。。没有对判断回文着过过程进行优化，一直TLE，把它考虑掉后就可以过了，这里把求字符串是否为回文的过程和求最小分割的过程合并了，并且考虑在不可能有更小分割的情况下快速进入下一个循环过程，悲剧的一天。