一、题目描述

​ 某种字符串处理语言允许程序员将字符串分为两段。将一个长为n的字符串分为两段耗时n个单位,因为这种操作会涉及旧字符串的复制工作。一个程序员想将字符串分为若干段，他所采用的划分次序会影响到总的用时情况。例如,假设我们想将一个有20个字符的字符串在第3个、第8个和第10个位置之后切断。如果我们按从左到右的次序切分,那么第一次切分耗时20个单位,第二次切分耗时17个单位,第三次切分耗时12个单位,共计49步。如果我们按从右到左的次序切分，那么第一次切分耗时20个单位，第二次切分耗时10个单位，第三次切分耗时8个单位,共计38步.

​ 给出一种动态规划算法,以字符位置的列表作为输入,只能在这些位置之后进行切分,要求在O(n3)时间内算出最少的切分花费并输出。

示例：

输入：partitions = [3, 8, 10] strLength = 20
输出：37
解释：切分顺序依次为10,3,8则为37
	 切分顺序依次为3,8,10则为49
	 切分顺序依次为10,8,3则为38

• 1
• 2
• 3
• 4
• 5

二、解题思路

​ 首先根据切点位置从小到大进行排序，为了便于计算需要加入切点位置0和字符串长度。如上列中排序并加入切点位置后数组为[0,3,8,10,20]。此题跟矩阵链乘法很相似，读者可以对比两题的解法。

1. 定义状态

​ 设dp[i][j]为第i个切点位置到第j个切点位置的最少切分花费，i和j从1开始计数，那我们最终要求出的是dp[1][partitions.length]即为切点位置partitions[1-1] = 0到 partitions[partitions.length -1]=20的最少切分费用。

​ 我么可以对dp[i][j]进行拆分，如果i和j满足j - i > 1时，则i和j中间必有一切点k,其切点k的位置在partitions[k-1]处，所以dp[i][j] = dp[i][k] + dp[k][j] + (partitions[j] - partitions[i])，其中partitions[j] - partitions[i]为在切点partitions[k-1]进行切分的花费，当然切点k可能出现多个，我们取最小花费那个。

2. 定义状态转移方程

当j - i <= 1时，有
​ $$dp[i][j]=0$$
否则
​ $$dp[i][j]=max(dp[i][k]+dp[k][j]+(partitions[j]-partitions[i]))$$

3. 初始化

​ 当j - i <= 1时，有$$dp[i][j]=0$$

4. 计算方式

​ 自底向上，自左向右计算。这里解释下是指dp二维表自底向上是指i从大往小计算，自左向右计算是指j从小到大计算。

三、代码实现

/**
 * 最小字符串划分问题
 *
 * @author hh
 * @date 2021-5-18 22:41
 */
public class MinStringPartition {

    public int minStringPartition(int[] partitions, int strLength, int[][] breaks) {
        int[][] dp = new int[partitions.length + 1][partitions.length + 1];
        //自顶向上，自左向右计算即可
        for (int i = partitions.length; i >= 1; i--) {
            for (int j = 1; j <= partitions.length; j++) {
                dp[i][j] = Integer.MAX_VALUE;
                if (j - i <= 1) {
                    dp[i][j] = 0;
                    continue;
                }
                for (int k = i + 1; k < j; k++) {
                    int temp = dp[i][k] + dp[k][j] + partitions[j-1] - partitions[i-1] ;
                    if (dp[i][j] > temp) {
                        dp[i][j] = temp;
                        breaks[i][j] = k;
                    }
                }
            }
        }
        return dp[1][partitions.length];
    }

    public void print(int[] partitions ,int[][] breaks, int start, int end) {
        if (end - start >= 2) {
            System.out.print(partitions[breaks[start][end] - 1] + " ");
            print(partitions,breaks, start, breaks[start][end]);
            print(partitions,breaks, breaks[start][end], end);
        }
    }

    public static void main(String[] args) {

        int[] partitions = new int[]{0,3, 8, 10,20};
        int strLength = 20;
        int[][] breaks = new int[strLength + 1][strLength + 1];
        MinStringPartition minStringPartition = new MinStringPartition();
        System.out.println(minStringPartition.minStringPartition(partitions, strLength, breaks));
        minStringPartition.print(partitions,breaks,1,partitions.length);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48

四、执行结果

五、思考

​ 本题和矩阵链乘法的做法非常相似，都是对dp数组进行线性划分，读者有时间可以看我的另一篇文章动态规划经典题目-矩阵链乘法，进行举一反三。