leetcode | 132. Palindrome Partitioning II

题目

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

Example:

Input: "aab"
Output: 1
Explanation: The palindrome partitioning ["aa","b"] could be produced using 1 cut.

思路与解法

此题目要求我们计算将字符串s切分为回文子串的最小切割次数。
对于题目中的样例字符串"aab"，我们想要得到该字符串的最小切分次数，首先需要判断字符串是否为回文序列，如果该字符串为回文序列，那么万事大吉。然而，大多数情况下输入字符串是不可能为回文序列的，所以我们需要进行切分操作，即我们需要找到该字符串的连续回文子串的最少个数，但是最开始我们需要得到一个字符串是否满足回文。
我们可以采用动态规划的思想来解决该问题，首先定义以下dp数组：
dp[i][j]表示从s[i:j+1]（左闭右开）是否为回文序列，如果是回文序列，则dp[i][j]=1；否则dp[i][j]=0。
同时，可以推出状态转移方程为：

// 情况1：i+1 == j (长度等于2的子串)
if s[i] == s[j] {
	dp[i][j] = 1
}
// 情况1：i+1 < j (长度大于2的子串)
if dp[i+1][j-1] == 1 && s[i] == s[j] {
	dp[i][j] = 1
}

此时，我们得到了字符串s的所有子串是否满足回文的dp数组：时间复杂度为$O(N^2)$。相比较于循环遍历字符串并首尾判断回文的方法要快上许多，后者复杂度为$O(N^3)$。
之后，我们需要计算将该字符串切分所需要的最少切分数，定义如下数组，minCuts[i]表示字符串s[:i]（前i个字符，minCuts下标从1~len(s)，与dp数组下标范围不同）切分为回文子串的最小切分数，则状态转移方程为：

// 下属if条件句中，j<i
// dp[j-1][i-1]为1，表示s[j-1:i]（左闭右开）为回文序列
if dp[j-1][i-1] == 1 && minCuts[i] > minCuts[j-1] + 1 {
	minCuts[i] = minCuts[j-1] + 1
}

代码实现（Go）

const INT_MAX = int(^uint(0) >> 1) 
func minCut(s string) int {
    lenS := len(s)
    dp := make([][]int, lenS)
    minCuts := make([]int, lenS+10)
    // 初始化dp数组，dp[i][i]=1
    // 初始化minCuts[2~lenS] = INT_MAX
    for i:=0; i<lenS; i++ {
        dp[i] = make([]int, lenS)
        dp[i][i] = 1
        minCuts[i+1] = INT_MAX
    }
    // 长度为0的字符串最小切分数设置为-1；长度为1的字符串最小切分数设置为0
    minCuts[0] = -1
    minCuts[1] = 0
    // 注意循环的顺序，j在外层
    // 简单讲是因为dp[0][lenS]应该在已知dp[1][lenS-1]后在计算获得
    for j:=0; j<lenS; j++ {
        for i:=0; i<lenS; i++ {
            if j > i {
                if dp[i+1][j-1]==1 && s[i] == s[j] {
                    dp[i][j] = 1
                } else if i+1==j && s[i] == s[j] {
                    dp[i][j] = 1
                }
            }
        }
    }
	// 获得minCuts，为方便处理边界，我将minCuts的下标定义为1~lenS
    for i:=1; i<=lenS; i++ {
        for j:=1; j<=i; j++ {
            if dp[j-1][i-1] == 1 && minCuts[i] > minCuts[j-1] + 1 {
                minCuts[i] = minCuts[j-1] + 1
            }
        }
    }

    return minCuts[lenS]
}

运行结果

总体时间复杂度为$O(N^2)$:

递归解法

最初我采用递归来实现（dp数组计算方法同上），递归更加容易理解，我们在计算s的最小切分数时，求得s[:k]、s[k:](其中1<=k<lenS)最小切分数之和得最小值，即为s得最小切分数。

for k:=i+1; k<=j; k++ {
    cuts1 := getMinCuts(i, k-1, s)
    cuts2 := getMinCuts(k, j, s)
    if cuts1 + cuts2 + 1 < minCuts {
        minCuts = cuts1 + cuts2 + 1
    }
}

但是，上述方法中做了许多无用的计算（并不能通过后三组数据），不满足dp[i][k-1]==1得计算时多余的，所以我进行了改进：

const INT_MAX = int(^uint(0) >> 1) 
var cutsMap map[string]int
var dp [][]int

func getMinCuts(i, j int, s string) int{
    if cutsMap[s[i:j+1]]!=0 {
        return cutsMap[s[i:j+1]]
    }
    if dp[i][j] == 1 {
        return 0
    }
    minCuts := INT_MAX
    for k:=i+1; k<=j; k++ {
        if dp[i][k-1] == 1 {
            cuts := getMinCuts(k, j, s)
            if cuts + 1 < minCuts {
                minCuts = cuts + 1
            }
        }
    }
    cutsMap[s[i:j+1]] = minCuts
    return minCuts
}

func minCut(s string) int {
    cutsMap = make(map[string]int)
    lenS := len(s)
    dp = make([][]int, lenS)
    for i:=0; i<lenS; i++ {
        dp[i] = make([]int, lenS)
        dp[i][i] = 1
    }
    for j:=0; j<lenS; j++ {
        for i:=0; i<lenS; i++ {
            if j > i {
                if dp[i+1][j-1]==1 && s[i] == s[j] {
                    dp[i][j] = 1
                } else if i+1==j && s[i] == s[j] {
                    dp[i][j] = 1
                }
            }
        }
    }
    return getMinCuts(0, lenS-1, s)
}