十四、动态规划
分冶：
-
无重叠，直接递归
-
有重叠 ，建立 dp表
class Solution {
public int minCostClimbingStairs(int[] cost) {
int[] dp = new int[]{cost[0], cost[1]};
for (int i = 2; i < cost.length; i++) {
dp[i % 2] = Math.min(dp[(i - 1) % 2], dp[(i - 2) % 2]) + cost[i];
}
return Math.min(dp[0], dp[1]);
}
}1.n序列问题
两种空间优化方案，一般可以转化成双序列
打家劫舍
剑指 Offer II 089. 房屋偷盗 = 198. 打家劫舍
单序列
class Solution {
public int rob(int[] nums) {
if(nums.length == 0) return 0;
int[] dp = new int[nums.length];
dp[0] = nums[0];
if(nums.length > 1){
dp[1] = Math.max(nums[0], nums[1]);
}
for(int i = 2; i < nums.length; i++){
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[nums.length - 1];
}
}转化成双序列
class Solution {
public int rob(int[] nums) {
if (nums.length == 0) return 0;
int[][] dp = new int[2][2];
dp[0][0] = 0;
dp[1][0] = nums[0];
for (int i = 1; i < nums.length; i++) {
dp[0][i % 2] = Math.max(dp[0][(i - 1) % 2], dp[1][(i - 1) % 2]);
dp[1][i % 2] = nums[i] + dp[0][(i - 1) % 2];
}
return Math.max(dp[0][(nums.length - 1) % 2], dp[1][(nums.length - 1) % 2]);
}
}剑指 Offer II 090. 环形房屋偷盗 = 213. 打家劫舍 II
把环拆成两个队列，一个是从0到n-1，另一个是从1到n，然后返回两个结果最大的。
class Solution {
public int rob(int[] nums) {
//长度为0
if (nums.length == 0) return 0;
//长度为1
if (nums.length == 1) return nums[0];
//长度>=2
int res1 = helper(nums, 0, nums.length - 2);
int res2 = helper(nums, 1, nums.length - 1);
return Math.max(res1, res2);
}
private int helper(int[] nums, int start, int end) {
int[] dp = new int[2];
dp[0] = nums[start];
if (start < end) {
dp[1] = Math.max(nums[start], nums[start + 1]);
}
for (int i = start + 2; i <= end; i++) {
int j = i - start;
dp[j % 2] = Math.max(dp[(j - 2) % 2] + nums[i], dp[(j - 1) % 2]);
}
return dp[(end - start) % 2];
}
}/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] result = robInternal(root);
return Math.max(result[0], result[1]);
}
public int[] robInternal(TreeNode root) {
if (root == null) return new int[2];
int[] result = new int[2];
int[] left = robInternal(root.left);
int[] right = robInternal(root.right);
//当前不偷 = 左边（偷或不偷） + 右边（偷或不偷）
result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
//当前偷 = 左边不偷 + 右边不偷 + 当前节点值
result[1] = left[0] + right[0] + root.val;
return result;
}
}涂色问题
剑指 Offer II 091. 粉刷房子 = 256. 粉刷房子
class Solution {
//三序列dp
public int minCost(int[][] costs) {
int n = costs.length;
for (int i = 1; i < n; i++) {
costs[i][0] += Math.min(costs[i - 1][1], costs[i - 1][2]);
costs[i][1] += Math.min(costs[i - 1][0], costs[i - 1][2]);
costs[i][2] += Math.min(costs[i - 1][0], costs[i - 1][1]);
}
return Math.min(Math.min(costs[n - 1][0], costs[n - 1][1]), costs[n - 1][2]);
}
public int minCost2(int[][] costs) {
int n = costs.length;
int[][] dp = new int[2][3];
dp[0] = costs[0];
for (int i = 1; i < n; i++) {
dp[i % 2][0] = Math.min(dp[(i - 1) % 2][1], dp[(i - 1) % 2][2]) + costs[i][0];
dp[i % 2][1] = Math.min(dp[(i - 1) % 2][0], dp[(i - 1) % 2][2]) + costs[i][1];
dp[i % 2][2] = Math.min(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1]) + costs[i][2];
}
return Math.min(Math.min(dp[(n - 1) % 2][0], dp[(n - 1) % 2][1]), dp[(n - 1) % 2][2]);
}
}265. 粉刷房子 II （上一道题的通用版本）
class Solution {
public int minCostII(int[][] costs) {
int n = costs.length;
int k = costs[0].length;
int res = Integer.MAX_VALUE;
for (int i = 1; i < n; i++) {
for (int j = 0; j < k; j++) {
int minTemp = Integer.MAX_VALUE;
for (int p = j + 1; p < j + k; p++) {
minTemp = Math.min(minTemp, costs[i - 1][p % k]);
}
costs[i][j] += minTemp;
}
}
for (int j = 0; j < k; j++) {
res = Math.min(res, costs[n - 1][j]);
}
return res;
}
}class Solution {
public int numWays(int n, int k) {
int[][] dp = new int[n][2];
dp[0][1] = k;//第一个栅栏有k种涂法（包含0和1两种情况）
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][1];
dp[i][1] = (dp[i - 1][0] + dp[i - 1][1]) * (k - 1);
}
return dp[n - 1][0] + dp[n - 1][1];
}
}力扣题解
class Solution {
public static int findIntegers(int n) {
/*
dp[i] = dp[i - 1] + dp[i - 2]
*/
int[] dp = new int[32];
dp[0] = 1;
dp[1] = 2;
for (int i = 2; i < 32; i++)
dp[i] = dp[i - 1] + dp[i - 2];
String numStr = getBinary(n);
int res = 0;
for (int i = 0; i < numStr.length(); i++) {
if (numStr.charAt(i) == '0') {
continue;
}
res += dp[numStr.length() - i - 1];
if (i != 0 && numStr.charAt(i - 1) == '1') {
return res;
}
}
return res + 1;
}
//get the binary form of number
//15 -> 1111
private static String getBinary(int num) {
StringBuilder sb = new StringBuilder();
while (num > 0) {
sb.insert(0, num & 1);
num >>= 1;
}
return sb.toString();
}
}656. 金币路径 **
从最后一个位置回退
0<= i <=length-2
dp[i] = min(A[i] + dp[j]) i+1<=j<=min(i+B,length) && A[j] >=0
next[i] = j of min_cost
输出路径
0<=i<length && next[i]>0——i+1
i == lenth -1 && coins[i] >= 0——length
else——null
class Solution {
public List<Integer> cheapestJump(int[] coins, int maxJump) {
List<Integer> res = new ArrayList<>();
int[] dp = new int[coins.length];
int[] next = new int[coins.length];
Arrays.fill(next, -1);
for(int i = coins.length - 2; i >= 0; i--){
int min_cost = Integer.MAX_VALUE;
for(int j = i + 1; j < coins.length && j <= i + maxJump ; j++){
if(coins[j] >= 0){
int cost = coins[i] + dp[j];
if(cost < min_cost){
min_cost = cost;
next[i] = j;
}
}
//如果j均不可达，则next[i]=-1；
}
dp[i] = min_cost;
}
int i;
for(i = 0; i < coins.length && next[i] > 0; i = next[i]){
res.add(i + 1);
}
if(i == coins.length - 1 && coins[i] >= 0){
res.add(coins.length);
}else{
return new ArrayList<>();
}
return res;
}
}
maxP[i] = max (cur*maxP[i-1], cur*minP[i-1], cur)
minP[i] = min (cur*maxP[i-1], cur*minP[i-1], cur)
class Solution {
public int maxProduct(int[] nums) {
int len = nums.length;
int maxP = nums[0];
int minP = nums[0];
int res = nums[0];
for (int i = 1; i < len; i++) {
int prevMaxP = maxP;
int prevMinP = minP;
maxP = Math.max(nums[i], Math.max(nums[i] * prevMaxP, nums[i] * prevMinP));
minP = Math.min(nums[i], Math.min(nums[i] * prevMaxP, nums[i] * prevMinP));
res = Math.max(res, maxP);
}
return res;
}
}53. 最大子数组和 （线段树）
法一：动态规划 dp O(n)：对于每一个i，dp[i]表示包含n[i]的最大子数组和，边迭代边找最大值
class Solution {
public int maxSubArray(int[] nums) {
int len = nums.length;
int[] dp = new int[len];
dp[0] = nums[0];
int res = nums[0];
for(int i = 1; i < len; i++){
dp[i] = Math.max(nums[i], nums[i]+dp[i-1]);
res = Math.max(dp[i], res);
}
return res;
}
}法二：前缀和
public class Solution {
public int maxSubArray(int[] nums) {
int ans = Integer.MIN_VALUE, sum = 0, min = 0;
for (int num : nums) {
sum += num;
ans = Math.max(ans, sum - min);
min = Math.min(sum, min);
}
return ans;
}
}法三：分冶
股票问题系列通解（转载翻译）
https://labuladong.github.io/algo/3/26/96/
-
base case：
-
dp[-1][...][0] = dp[...][0][0] = 0
-
dp[-1][...][1] = dp[...][0][1] = -infinity
-
-
状态转移方程：
-
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
-
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
-
剑指 Offer II 092. 翻转字符 （双序列递推）
-
末尾为0
-
末尾为1
int len = s.length();
//isPalindrome
boolean[][] isPal = new boolean[len][len];
for(int i = 0; i < len; i++){
for(int j = 0; j <= i; j++){
if(s.charAt(i) == s.charAt(j) && (i <= j + 1 || isPal[j+1][i-1])){
isPal[j][i] = true;
}
}
}2.双序列问题
if(text1.charAt(i-1) == text2.charAt(j-1)){
dp[i][j] = dp[i-1][j-1]+1;
}else{
dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
}583. 两个字符串的删除操作 （转化一下）
return len1 + len2 - 2 * dp[len1][len2];
注意 0 和另一字符串的 初始化 其他结构类似
注意行列边界初始化
dp[i + 1][j + 1] = (ch1 == ch3 && dp[i][j + 1]) || (ch2 == ch3 && dp[i + 1][j]);
3.矩阵路径问题
- 路径数量
- 路径的最大值，最小值
- 障碍物问题
剑指 Offer II 098. 路径的数目 无障碍物，求路径数
两种写法：二维数组，一维数组；第一行和第一列初始化为1
class Solution {
//动态规划，时间mn，空间n，用一行数组储存
public int uniquePaths(int m, int n) {
int[] dp = new int[n];
Arrays.fill(dp, 1);
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[j] += dp[j - 1];
}
}
return dp[n - 1];
}
}63. 不同路径 II (障碍物，求路径数)
两种写法：二维数组，一维数组；第一行和第一列初始化，碰到障碍物就变成0
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
int[][] dp = new int[m][n];
dp[0][0] = obstacleGrid[0][0] == 1 ? 0 : 1;
for (int i = 1; i < m; i++) {
dp[i][0] = obstacleGrid[i][0] == 1 ? 0 : dp[i - 1][0];
}
for (int j = 1; j < n; j++) {
dp[0][j] = obstacleGrid[0][j] == 1 ? 0 : dp[0][j - 1];
}
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[i][j] = obstacleGrid[i][j] == 1 ? 0 : dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
}class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
int[] dp = new int[n];
dp[0] = obstacleGrid[0][0] == 0 ? 1 : 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (obstacleGrid[i][j] == 1) {
dp[j] = 0;
} else if (j >= 1){
dp[j] += dp[j - 1];
}
}
}
return dp[n - 1];
}
}剑指 Offer II 099. 最小路径之和（无障碍物）
两种写法：二维数组，一维数组
思路都是让第一列和第一行持续累加，其余用min函数比较
class Solution {
public int minPathSum(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
int[] dp = new int[n];
dp[0] = grid[0][0];
for (int j = 1; j < n; j++) {
dp[j] = grid[0][j] + dp[j - 1];
}
for (int i = 1; i < m; i++) {
dp[0] += grid[i][0];
for (int j = 1; j < n; j++) {
dp[j] = Math.min(dp[j], dp[j - 1]) + grid[i][j];
}
}
return dp[n - 1];
}
}174. 地下城游戏（障碍物，路径和）
逆向思考，从最后一个位置倒推满足条件的生命值，同样地，先初始化最后一列和最后一行
// 状态转移方程
for(int i = m - 2; i >= 0; i--) {
for(int j = n - 2; j >= 0; j--) {
dungeon[i][j] = Math.max(Math.min(dungeon[i][j+1], dungeon[i+1][j]) - dungeon[i][j], 1);
}
}4.背包问题
问题特点
-
信息：一组物品，物品重量，物品价格
-
限定：总重量
-
目标：总价格最高
问题细分：
-
0-1背包问题：每种物品只有一个
-
有界背包问题：每种物品有多个
-
无限背包问题：每种物品有无穷多个
（1）0-1背包问题
（2）有界背包问题
多重背包问题：在0-1背包的基础上增加k个累加状态
for (int k = 0; k <= si; k++) {
if (j - k * wi >= 0) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * wi] + k * vi);
}
}（3）无限背包问题
求组合数：
377. 组合总和 Ⅳ 注意外层和内层循环的状态，这道题目标状态在外层，选择状态在内层 和回溯的区别（39. 组合总和）
518. 零钱兑换 II dp[j] = dp[j] + dp[j - coin]; 目标状态在内层，选择状态在外层；
目标值最大的典型问题：转化为一维问题，只进行依次判断，用j做dp传递，dp[j] = Math.max(dp[j], dp[j - w] + v)
目标状态在内层，选择状态在外层（交换也可以）
5.其他题型
（1）旅游最短路线
memo表（hash）+ dp函数递归；
注意各种边界情况
（2） 指针转盘
memo表 (hash) + dp函数递归
// 字符 -> 索引列表
HashMap<Character, List<Integer>> charToIndex = new HashMap<>();
// 备忘录
int[][] memo;
/* 主函数 */
int findRotateSteps(String ring, String key) {
int m = ring.length();
int n = key.length();
// 备忘录全部初始化为 0
memo = new int[m][n];
// 记录圆环上字符到索引的映射
for (int i = 0; i < ring.length(); i++) {
char c = ring.charAt(i);
if (!charToIndex.containsKey(c)) {
charToIndex.put(c, new LinkedList<>());
}
charToIndex.get(c).add(i);
}
// 圆盘指针最初指向 12 点钟方向，
// 从第一个字符开始输入 key
return dp(ring, 0, key, 0);
}
// 计算圆盘指针在 ring[i]，输入 key[j..] 的最少操作数
int dp(String ring, int i, String key, int j) {
// base case 完成输入
if (j == key.length()) return 0;
// 查找备忘录，避免重叠子问题
if (memo[i][j] != 0) return memo[i][j];
int n = ring.length();
// 做选择
int res = Integer.MAX_VALUE;
// ring 上可能有多个字符 key[j]
for (int k : charToIndex.get(key.charAt(j))) {
// 拨动指针的次数
int delta = Math.abs(k - i);
// 选择顺时针还是逆时针
delta = Math.min(delta, n - delta);
// 将指针拨到 ring[k]，继续输入 key[j+1..]
int subProblem = dp(ring, k, key, j + 1);
// 选择「整体」操作次数最少的
// 加一是因为按动按钮也是一次操作
res = Math.min(res, 1 + delta + subProblem);
}
// 将结果存入备忘录
memo[i][j] = res;
return res;
}
（3）
扫一扫
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
