LeeCode 动态规划（一）

简述

如果某一问题存在很多重叠子问题，使用动态规划是非常有效的。

动态规划与贪心

• 贪心：每次都选择局部最优解
• 动态规划：每个状态都是由前一个状态推导得到

动态规划解题步骤

1. 确定 dp数组 及下标的含义
2. 确定递推公式
3. dp数组 初始化
4. 确定遍历顺序

LeeCode 509：斐波那契数

题目描述

斐波那契数（通常使用 F(n) 表示）形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。即 \(F(0) = 0;F(1) = 1; F(n) = F(n - 1) + F(n - 2) \quad n > 1\)。给定 n ，请计算 F(n)。

建立模型

• 确定dp数组及下标的含义, 这里省略了dp数组(当前状态只和前两个状态有关), 借用两个参数a, b来代替. 数组的含义为 F(i)
• 确定递推公式, dp[i] = dp[i - 1] + dp[i - 2] 即 res = a + b
• dp数组初始化, dp[0] = 0, dp[1] = 1 即 a = 0, b = 1
• 确定遍历顺序, 2 ~ n顺序遍历

代码实现

public int fib(int n) {
  if (n <= 1) {
    return n;
  }

  int a = 0, b = 1;
  int res = 1;
  for (int i = 2; i <= n; i++) {
    res = a + b;
    a = b;
    b = res;
  }

  return res;
}

LeeCode 70：爬楼梯

题目描述

假设你正在爬楼梯，需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

建立模型

此题与斐波那契数列属于同一题, 不过此次笔者没有省略 dp数组.

• 确定dp数组及下标的含义, 数组的含义为爬到第 i 阶楼梯的方法数
• 确定递推公式 dp[i] = dp[i - 1] + dp[i - 2]
• dp数组初始化, dp[1] = 1, dp[2] = 2
• 确定遍历顺序, 3~n 顺序遍历

代码实现

public int climbStairs(int n) {
  if (n <= 2) {
    return n;
  }

  int[] dp = new int[n + 1];

  // dp数组初始化
  dp[1] = 1;
  dp[2] = 2;

  for (int i = 3; i < dp.length; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }

  return dp[n];
}

LeeCode 746：使用最小花费爬楼梯

题目描述

给你一个整数数组 cost ，其中 cost[i] 是从第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或 下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

建立模型

• 确定dp数组及下标的含义, 数组的含义为到达第 i 个台阶的最小花费
• 确定递推公式 dp[i] = Math.min(dp[i - 1] + dp[i - 2]) + cost[i]
• 初始化dp数组, dp[0] = cost[0], dp[1] = cost[1]
• 确定遍历顺序, 从 2~n 顺序遍历

代码实现

public int minCostClimbingStairs(int[] cost) {
  if (cost.length == 2) {
    return Math.min(cost[0], cost[1]);
  }

  int[] dp = new int[cost.length];

  dp[0] = cost[0];
  dp[1] = cost[1];

  for (int i = 2; i < dp.length; i++) {
    /**
     * 递推数组
     * 爬到第 i 阶楼梯的方式包括 从 i - 1 阶爬一个台阶 和 从 i - 2 阶爬两个台阶
     * 取其中的花费较小者
     */
    dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
  }

  /**
   * 到达顶部的花费选择 倒数第一个台阶和倒数第二个台阶的较小者
   */
  return Math.min(dp[cost.length - 1], dp[cost.length - 2]);
}

LeeCode 62：不同路径

题目描述

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

建立模型

• 确定dp数组及下标含义, 数组的含义为到达第i行第j列的路径总数
• 确定递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
• 初始化dp数组, 第0行和第0列全都初始化为1
• 确定遍历顺序, 外循环从左至右, 内循环从上至下

代码实现

public int uniquePaths(int m, int n) {
  int[][] dp = new int[m][n];

  // dp数组初始化
  // 第 0 行初始化
  for (int i = 0; i < n; i++) {
    dp[0][i] = 1;
  }
  // 第 0 列初始化
  for (int j = 0; j < m; j++) {
    dp[j][0] = 1;
  }

  for (int i = 1; i < m; i++) {
    for (int j = 1; j < n; j++) {
      dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
    }
  }

  return dp[m - 1][n - 1];

}

LeeCode 63：不同路径II

题目描述

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

建立模型

• 确定dp数组及下标的含义, 数组的含义为到达第i行第j列的路径总数
• 确定递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1], 对于网格中的障碍物有dp[i][j] = 0
• 初始化dp数组, dp[0][0]根据是否有障碍物初始化为0或1, 对于第0行, 则根据左边是否有障碍物初始化为0或1, 第0列则根据上边是否有障碍无初始化为0或1
• 确定遍历顺序, 外循环从左至右, 内循环从上至下

代码实现

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
  int m = obstacleGrid.length;
  int n = obstacleGrid[0].length;

  int[][] dp = new int[m][n];

  // dp数组初始化
  if (obstacleGrid[0][0] == 1) {
    dp[0][0] = 0;
  }
  else {
    dp[0][0] = 1;
  }

  // 第 0 行初始化
  for (int i = 1; i < n; i++) {
    if (obstacleGrid[0][i] == 1) {
      dp[0][i] = 0;
    }
    else {
      dp[0][i] = dp[0][i - 1];
    }
  }

  // 第 0 列初始化
  for (int j = 1; j < m; j++) {
    if (obstacleGrid[j][0] == 1) {
      dp[j][0] = 0;
    }
    else {
      dp[j][0] = dp[j - 1][0];
    }
  }

  // 遍历dp数组
  for (int i = 1; i < m; i++) {
    for (int j = 1; j < n; j++) {
      if (obstacleGrid[i][j] == 1) {
        dp[i][j] = 0;
      }
      else {
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
      }
    }
  }

  return dp[m - 1][n - 1];
}

LeeCode 343：整数拆分

题目描述

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

建立模型

• 确定dp数组及下标的含义, 数组的含义为 i 可拆分成的乘积最大值
• 确定递推公式 dp[i] = MAX(Math.max(j * (i - j), j * dp[i - j])) (1 <= j < i)
• 初始化dp数组, 全都初始化为0
• 确定遍历顺序, i -> 2~n, j -> 1~(i-1)

代码实现

public int integerBreak(int n) {
  int[] dp = new int[n + 1];
  
  for (int i = 2; i <= n; i++) {
    int max_value = 0;
    for (int j = 1; j < i; j++) {
      /**
       * j * (i - j)   表示 (i - j) 不继续拆分的乘积值
       * j * dp[i - j] 表示 (i - j) 继续拆分的乘积值
       */
      max_value = Math.max(max_value, Math.max(j * (i - j), j * dp[i - j]));
    }
    dp[i] = max_value;
  }

  return dp[n];
}

LeeCode 96：不同的二叉搜索树

题目描述

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

建立模型

• 确实dp数组及其下标的含义, 数组的含义为 i 个节点能构成的不同的二叉搜索树

• 初始化dp数组, dp[0] = dp[1] = 1, 空树或单节点的树只有一种

• 确定递推公式, dp[i] += dp[j] * dp[i - j - 1], 该公式的意思为依次遍历每个 \

  数字将其作为根节点, 将 1~j-1 作为左子树, j+1~i 作为右子树, 同时左右子树也 \

  需要满足是二叉搜索树, 且由于根值不同, 可以保证每棵二叉搜索树都是不同的, 所以 \

  该问题就转化成了两个规模更小的问题。

• 确定遍历顺序, i -> 2~n, j -> 1~i

代码实现

public int numTrees(int n) {
  int[] dp = new int[n + 1];

  // dp数组初始化
  dp[0] = 1;
  dp[1] = 1;

  // 遍历数组
  for (int i = 2; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
      dp[i] += dp[j - 1] * dp[i - j];
    }
  }

  return dp[n];
}

标签：初始化,遍历,int,LeeCode,cost,数组,动态,规划,dp
来源： https://www.cnblogs.com/ylyzty/p/16672472.html