动态规划注意以下几点:
- 核心:当前状态可以由前面的状态得到
1、dp[i][j]或者dp[i]表示的具体意义
2、初始的值是多少
3、状态转移方程
4、返回值是什么
Leetcode 64
解析:
- 定义:利用二维数组动态规划来做,dp[i][j]表示从左上角到当前位置(i, j)的最小路径和,grid表示输入的二维数组。
- 初始化:dp[0][0] = grid[0][0],左上角到左上角的最小路径和就是本身,对于第一行的数据只能通过左上角逐步向右移动得到 dp[0][i] = dp[0][i-1] + grid[0][i],对于第一列的数据只能通过左上角逐步向下移动得到 dp[i][0] = dp[i-1][0] + grid[i][0],
- 状态转移方程:其余数据,只能通过当前位置的左边或者上边数据移动得到:dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1])
- 返回值:dp[m-1][n-1],表示从左上角到右下角的最小路径和
解法1:
public class test {
public static int minPathSum(int [][] grid) {
int m = grid.length, n = grid[0].length;
int [][] dp = new int [m][n];
dp[0][0] = grid[0][0];
//第一列只有由数字向下移动得到
for (int i = 1; i < m; i++) dp[i][0] = grid[i][0] + dp[i-1][0];
//第一行只能有数字向右移动得到
for (int j = 1; j < n; j++) dp[0][j] = grid[0][j] + dp[0][j-1];
//循环从1开始,不包括第一行和第一列
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[i][j] = grid[i][j] + Math.min(dp[i-1][j], dp[i][j-1]);
}
}
//dp[i][j]表示从左上角到当前位置的最小路径和,目前为右下角位置
return dp[m-1][n-1];
}
public static void main(String[] args) {
int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
int result = minPathSum(grid);
System.out.println(result);
}
}
解法2:
或者使用下面的这种方式,一模一样的,
public class test {
public static int minPathSum(int [][] grid) {
int m = grid.length, n = grid[0].length;
int [][] dp = new int [m][n];
for (int i =0; i < m; i++) {
for (int j =0; j < n; j++) {
if (i == 0) {
//初始值grid[0][0]
if (j == 0) {
dp[i][j] = grid[i][j];
}
//第一行,数字只能向右移动
else {
dp[i][j] = dp[i][j-1] + grid[i][j];
}
}
//第一列,数据只能向下移动
else if (j == 0) {
dp[i][j] = dp[i-1][j] + grid[i][j];
}
//一般情况
else {
dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
}
}
}
return dp[m-1][n-1];
}
public static void main(String[] args) {
int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
int result = minPathSum(grid);
System.out.println(result);
}
}
解法3:
空间优化,使用一维数组,不停的覆盖原有的值即可
ps:在解法2的基础上,直接将【i】那一项去掉即可
public class test {
public static int minPathSum(int [][] grid) {
int m = grid.length, n = grid[0].length;
int [] dp = new int [n];
for (int i =0; i < m; i++) {
for (int j =0; j < n; j++) {
if (i == 0) {
//初始值grid[0][0]
if (j == 0) {
dp[j] = grid[i][j];
}
//第一行,数字只能向右移动
else {
dp[j] = dp[j-1] + grid[i][j];
}
}
//第一列,数据只能向下移动
else if (j == 0) {
dp[j] = dp[j] + grid[i][j];
}
//一般情况
else {
dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j];
}
}
}
return dp[n-1];
}
public static void main(String[] args) {
int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
int result = minPathSum(grid);
System.out.println(result);
}
}
Leetcode 53
解析:
- 定义:dp[i]表示以nums[i]结尾的最大子数组的和
- 初始化:dp[0] = nums[0]
- 状态转移方程:dp[i]对应的连续子数组中如果不包含nums[i-1],那么dp[i] = nums[i];如果包含了nums[i-1],那么就包含了以nums[i-1]结尾的最大子数组的和dp[i-1],即dp[i] = dp[i-1] + nums[i],综上得到状态转移方程dp[i] = dp[i-1]+nums[i]
- 返回值:dp[0]、dp[1]、…dp[n-1]中的最大值,其中n = nums.length
解法1、
public class test {
public static int maxSubArray(int[] nums) {
int n = nums.length;
int [] dp = new int[n];
//初始化
dp[0] = nums[0];
int res = dp[0];
for (int i = 1; i < n; i++) {
//状态转移,注意从i = 1开始循环
dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
//返回所有dp[i]中的最大值
res = Math.max(dp[i], res);
}
return res;
}
public static void main(String[] args) {
int [] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 5};
int result = maxSubArray(nums);
System.out.println(result);
}
}
解法2、
空间优化,在解法1的基础上使用常数代替dp一维数组
ps:因为算法中dp[i]的值只与dp[i-1]有关,我们并不需要把每个dp[i]的值存储下来
public class test {
public static int maxSubArray(int[] nums) {
int n = nums.length;
int endHere = nums[0];
int res = nums[0];
for (int i = 1; i < n; i++) {
//状态转移,注意从i = 1开始循环
endHere = Math.max(endHere + nums[i], nums[i]);
//返回所有dp[i]中的最大值
res = Math.max(endHere, res);
}
return res;
}
public static void main(String[] args) {
int [] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 5};
int result = maxSubArray(nums);
System.out.println(result);
}
}