一文解决区间dp问题

区间dp的理解

对于一段区间的元素进行操作，操作必须是连续的，求解，在这段区间上的属性(Min / Max),考虑动态规划的考虑方式。

模板

所有的区间dp问题枚举时，第一维通常是枚举区间长度，并且一般 len = 1 时用来初始化，枚举从 len = 2 开始；第二维枚举起点 i （右端点 j 自动获得，j = i + len - 1）

for (int len = 1; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 枚举起点
        int j = i + len - 1;                 // 区间终点
        if (len == 1) {
            dp[i][j] = 初始值
            continue;
        }

        for (int k = i; k < j; k++) {        // 枚举分割点，构造状态转移方程
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);
        }
    }
}

---

题目整理

1.石子合并
2.leetcode87 扰乱字符串

---

1.石子合并

采用闫式dp分析法,本题的关键点在于：最后一次合并一定是左边连续的一部分和右边连续的一部分进行合并。

f[i][j表示将i到j这一段石子合并成一堆的方案的集合，属性为Min.依据上图的状态计算可以得到最终的答案就是f[1][n].

• 代码

import java.util.*;

public class Main{
    static int N = 310;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] s = new int[N];
        // f[i][j]表示合并区间[i,j]这些石子的方案 属性为Min
        int[][] f = new int[N][N];
        
        int n = sc.nextInt();
        
        // 初始化前缀和
        for(int i = 1; i <= n; i++) s[i] = sc.nextInt();
        for(int i = 1; i <= n; i++) s[i] += s[i - 1];
        
        // 区间dp枚举的是dp的长度
        for(int len = 2; len <= n; len++) {
            // 枚举左端点
            for(int i = 1; i + len - 1 <= n; i++){
                int l = i, r = i + len - 1;
                f[l][r] = Integer.MAX_VALUE; // 因为要求最小值 初始化f[i][j]为最大值
                // 枚举[i,j]区间里最小代价的方案
                for(int k = l; k < r; k++) {
                    f[l][r] = Math.min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
                }
            }
        }
        
        System.out.println(f[1][n]);
        
    }
}

---

2.扰乱字符串

• 题目分析:

本题中对于字符串的两种操作，首先是两个字符串s1和s2，也就是说如果采用dp的思路，状态表示的时候需要二维f[i][j],并且i和j分别表示s1和s2的起点。此外，对于区间dp来说，首先枚举的一定是区间的长度,因此状态表示f[i][j][k]。

• f[i][j][k]

集合：s1[i ~ i + k - 1]与s2[j, j + k - 1]所有匹配方案的集合
属性： 集合是否非空

• 状态计算
  

将f[i, j, k]表示的集合按s1第一段的长度划分划分成k - 1类。
设s1第一段的长度为u。则s1[i ~ i + k - 1]与s2[j, j + k - 1]有两种匹配方案，分别判断即可：
(1).f[i][j][u] && f[i + u][j + u][k - u].
(2).f[i][j][u] && f[i + u][j + u][k - u]

• 代码

class Solution {
    public boolean isScramble(String s1, String s2) {
        int n = s1.length();
        if(s1.equals(s2)) return true;
        if(s1.length() != s2.length()) return false;

        // f[i][j][k]表示s1[i,i+k-1]和s2[j,j+k-1]所有的匹配方案 属性是是否非空
        boolean[][][] f = new boolean[n + 1][n + 1][n + 1];

        // 区间dp枚举区间长度
        for(int k = 1; k <= n; k++) {
            for(int i = 0; i + k - 1 < n; i++) {
                for(int j = 0; j + k - 1 < n; j++) {
                    if(k == 1) {
                        if(s1.charAt(i) == s2.charAt(j)) f[i][j][k] = true; 
                    } else {
                        for(int u = 1; u < k; u++) {
                            // 状态计算
                            if(f[i][j][u] && f[i + u][j + u][k - u] || f[i][j + k - u][u] && f[i + u][j][k - u]) {
                                f[i][j][k] = true;
                                break;
                            }
                        }
                    }
                }
            }
        }

        return f[0][0][n];

    }
}

---

未完待续