动态规划4 划分型动态规划

题目1：LintCode 108 Palindrome Partitioning II

题目2：LintCode 108 Palindrome Partitioning II

Input: "aab"
Output: 1
Explanation: Split "aab" once, into "aa" and "b", both palindrome.

将字符串每一段划分成字符串最少划分几次      划分最少，也就是回文串最长

确定状态：

最后一段回文串S[j..N-1]  需要知道S前j个字符串S[0..j-1]最少可以划分成几个字符串

dp[i]:设S前i个字符最少爱可以划分成几个字符串

最后一个回文串长度至少是1，所有j是从0到i-1

　　　　　　　　假设：最后是一段回文串

dp[i] = min{dp[j]+1}  | S[j..i-1]是回文串     区间    [0, 1, 2,   j ... i-1, i] 

　　　j=0..i-1

dp[0] = 0;空串可以被分成0个回文串

怎么判断回文串:

• 奇数   中轴外，左右两边都一样
• 偶数   左右两边都一样

以每个子串为中心向两边扩展     时间复杂度 0(n^2)

用isPalin[i][j]:表示s[i,j]是否是回文串 

dp[i] = min{dp[j]+1}  | S[j..i-1]是回文串    ====> dp[i] = min{dp[j]+1}  | isPalin[i][j]=True

答案是F[N]-1 最少划分几次    F[N]：表示以N为结尾有最少多少回文串。

时间复杂度 0(n^2)   空间复杂度 0(n^2)

public class Solution {
    /**
     * @param s: A string
     * @return: An integer
     */
    public int minCut(String ss) {
        // write your code here
        char[] s = ss.toCharArray();
        int n = s.length;
        if(n==0){
            return 0;
        }
        boolean[][]  isPalin = new boolean[n][n];
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                isPalin[i][j] = false;
            }
        }
        int i, j, t;
        // 判断i到j是否为回文串
        for(t=0; t<n; t++){
            // old-length
            i=j=t;
            while(i>=0 && j<n && s[i]==s[j]){
                isPalin[i][j] = true;
                i--;
                j++;
            }
            
            // even length
            i = t;
            j = t+1;
            while(i>=0 && j<n && s[i]==s[j]){
                isPalin[i][j] = true;
                i--;
                j++;
            }
        }
        
        int[] dp = new int[n+1];
        dp[0]=0;
        for(i=1; i<=n; i++){
            dp[i] = Integer.MAX_VALUE;
            for(j=0; j<i; j++){
                if(isPalin[j][i-1]){
                    dp[i] = Math.min(dp[j]+1, dp[i]);
                }
            }
        }
        
        // dp[i] = min j=0..i-1 {f[j]+1 | isPalin[j][i-1] = True}
        
        return dp[n]-1;
    }
}

题目3：LintCode 437 Copy Books

K个抄写员，可以抄写连续的若干本(每个抄写员碎度都一样每一份一页)

问最少需要多少时间可以抄写完

抄写员抄写第i本到第j本需要时间 : A[i]+A[i+1]+...+A[j]

找一种划分方式，不超过k段，使得每段所有的数字之和的最大值最小

最后一步：A[j]+..+A[N-1]

需要知道钱k-1个人最少需要多少时间抄写完前j本书（0-j-1本书）

f[k][i]:为k个抄写员最少需要多少时间抄完前i本书  （如果这边加k就表示抄写员的个数为任意多个，用k来记录状态）

f[k][i] = min {max{f[k-1][j], A[j]+A[j+1]+...+A[i-1]}}

         j=0,...,j

初始条件：

• f[0][0]=0,   
• f[0][1]=f[0][2]=...=f[0][N]=+无穷 代表不能抄,去最小值
• f[k][0]=0;

public class Solution {
    /**
     * @param pages: an array of integers
     * @param k: An integer
     * @return: an integer
     */
    public int copyBooks(int[] A, int K) {
        // write your code here
        int n = A.length;
        if(n==0){
            return 0;
        }
        if(K > n){
            K = n;
        }
        
        int[][] dp = new int[K+1][n+1];
        int i, j, k;
        
        dp[0][0] = 0;
        for(j=1; j<=n; j++){
            dp[0][j] = Integer.MAX_VALUE;
        }
        
        int sum = 0;
        for(k=1; k<=K; k++){
            dp[k][0] = 0;
            for(i=1; i<=n; i++){
                sum = 0;
                dp[k][i] = Integer.MAX_VALUE;
                //import j 是从j到i-1
                for(j=i; j>=0; j--){
                    dp[k][i] = Math.min(dp[k][i], Math.max(dp[k-1][j], sum));
                    if(j > 0){
                        sum += A[j-1];
                    }
                }
            }
            // f[k][j] = min j=0..i {max{f[k-1][j], A[j]+...+A[i-1]}}
        }
        
        return dp[K][n];
    }
}