动态规划刷题——滚动数组的优化

动态规划刷题——滚动数组的优化

1. [最后一块石头的重量II]第二个维度变为从大到小遍历的情况

注意这里的空间压缩写的非常典型
https://leetcode-cn.com/problems/last-stone-weight-ii/solution/zui-hou-yi-kuai-shi-tou-de-zhong-liang-i-95p9/

原来的代码为

   boolean[][] dp = new boolean[n + 1][m + 1];
   dp[0][0] = true;
   for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j < stones[i])
                    dp[i + 1][j] = dp[i][j];
                else
                    dp[i + 1][j] = dp[i][j] || dp[i][j - stones[i]];

            }
        }

空间压缩后

    boolean[] dp = new boolean[m + 1];
    dp[0] = true;
    for (int weight : stones) {
        for (int j = m; j >= weight; --j) {
            dp[j] = dp[j] || dp[j - weight];
        }
    }

2. [一和零]第二个维度和第三个维度变为从大到小遍历的情况

https://leetcode-cn.com/problems/ones-and-zeroes/solution/yi-he-ling-by-leetcode-solution-u2z2/
原来

for (int i = 1; i <= length; i++) {
        int[] zerosOnes = getZerosOnes(strs[i - 1]);
        int zeros = zerosOnes[0], ones = zerosOnes[1];
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= n; k++) {
                dp[i][j][k] = dp[i - 1][j][k];
                if (j >= zeros && k >= ones) {
                    dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j - zeros][k - ones] + 1);
                }
            }
        }
    }

空间压缩后

for (int i = 0; i < length; i++) {
        int[] zerosOnes = getZerosOnes(strs[i]);
        int zeros = zerosOnes[0], ones = zerosOnes[1];
        for (int j = m; j >= zeros; j--) {
            for (int k = n; k >= ones; k--) {
                dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
            }
        }
}

2. [硬币]第二个维度还是从小到大遍历的情况

https://leetcode-cn.com/problems/coin-lcci/solution/ying-bi-by-leetcode-solution/
原来

for (int i = 1; i <= 4; i++) {
        for (int j = 1; j <= n; j++) {
            if (j < coins[i]) {
                ans[i][j] = ans[i - 1][j];
            } else {
                ans[i][j] = (ans[i - 1][j] + ans[i][j - coins[i]]) % mod;
            }
        }
}

空间压缩后

f[0] = 1;
for (int c = 0; c < 4; ++c) {
    int coin = coins[c];
    for (int i = coin; i <= n; ++i) {
        f[i] = (f[i] + f[i - coin]) % MOD;
    }
}