目录
刷题日期:下午8:10 2021年5月11日星期二
个人刷题记录,代码收集,来源皆为leetcode
经过多方讨论和请教,现在打算往Java方向发力
主要答题语言为Java
题目:
剑指 Offer 47. 礼物的最大价值
难度中等136
在一个 m*n 的棋盘的每一格都放有一个礼物,每个礼物都有一定的价值(价值大于 0)。你可以从棋盘的左上角开始拿格子里的礼物,并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值,请计算你最多能拿到多少价值的礼物?
示例 1:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物
提示:
0 < grid.length <= 200
0 < grid[0].length <= 200
题目分析
根据提示,格子最大为200 * 200,也不能算作是路径最大问题。
这种题型就能算作是动态规划了吧,每一步都要考虑下一步选哪里才能最大,从左上到右下。
可以用循环或者递归来解。
初始解答:
先尝试用循环:
class Solution {
public int maxValue(int[][] grid) {
int x = 0, y = 0, res = 0;//行,列,结果,初始位置不确定是不是这里
while(x != grid.length - 1 || y != grid[0].length - 1) {
res += grid[x][y]; //获得礼物
//到边缘的情况
if(x == grid.length - 1){
y++;
break;
}
if(y == grid[0].length - 1){
x++;
break;
}
//在循环内说明还没到右下角
if(grid[x + 1][y] >= grid[x][y + 1]) x++;
else y++;
}
res += grid[x][y]; //右下角
return res;
}
}
能跑的通示例但是,执行结果:解答错误
显示详情 添加备注
输入:[[1,2,5],[3,2,1]]
输出:6
预期结果:9
还是有问题的,不纠结了,思路应该是没问题的,学习他人
看评论区说递归会超时
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length; //获得矩阵长宽
int[] dp = new int[n + 1]; //定义数组,为啥是n+1
for(int i = 1; i <= m; i++) {
for(int j = 1; j <= n; j++) {
//两层遍历,在每一层里都更新了dp
dp[j] = Math.max(dp[j], dp[j - 1]) + grid[i - 1][j - 1];
}
}
return dp[n];
}
}
这个其实没太看懂,只知道一直在更新dp,每一层都算一遍。
执行结果:通过
显示详情 添加备注
执行用时:2 ms, 在所有 Java 提交中击败了98.61%的用户
内存消耗:41 MB, 在所有 Java 提交中击败了87.03%的用户
学习K神的解法
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length; //长宽
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
//两层遍历
if(i == 0 && j == 0) continue; //起点
if(i == 0) grid[i][j] += grid[i][j - 1]; //顶
else if(j == 0) grid[i][j] += grid[i - 1][j];//左
else grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]); //判断
}
}
return grid[m - 1][n - 1];
}
}
可以说是相当直观了,怪不得能算简单题,能想到代码的思路基本就能写出来,好好学习
执行结果:通过
显示详情 添加备注
执行用时:3 ms, 在所有 Java 提交中击败了83.97%的用户
内存消耗:41.3 MB, 在所有 Java 提交中击败了28.62%的用户
事先处理边缘的代码,更直观简洁
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length; //长宽
for(int j = 1; j < n; j++) {
grid[0][j] += grid[0][j - 1];//相当于把一整行都挨个加上去了
}
for(int i = 1; i < m; i++) {
grid[i][0] += grid[i - 1][0];//相当于把一整列都挨个加上去了
}
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
grid[i][j] += Math.max(grid[i - 1][j], grid[i][j - 1]);
}
}
//原来Java也可以不用括号靠缩减来写循环和判断啊
return grid[m - 1][n - 1];
}
}
执行结果:通过
显示详情 添加备注
执行用时:3 ms, 在所有 Java 提交中击败了83.97%的用户
内存消耗:40.7 MB, 在所有 Java 提交中击败了98.79%的用户
学习他人:
方法一:
mata川L5 (编辑过)2020-03-08 来字节和孙哥做兄弟,最基础的dp题,转移方程:
f(i, j) = max{f(i - 1, j), f(i, j - 1)} + grid[i][j]
然后可以用滚动数组的技巧把空间复杂度优化成O(N)
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length;
int[] dp = new int[n + 1];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
dp[j] = Math.max(dp[j], dp[j - 1]) + grid[i - 1][j - 1];
}
}
return dp[n];
}
}
方法二:
爱吃喵酱的花椒L1 2021-02-19 简单题我重拳出击
class Solution {
public int maxValue(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]=dp[i-1][0]+grid[i][0];
for(int i=1;i<n;++i)
dp[0][i]=dp[0][i-1]+grid[0][i];
for(int i=1;i<m;++i)
for(int j=1;j<n;++j){
dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];
}
return dp[m-1][n-1];
}
}
方法三:
K神:
作者:jyd
链接:https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/solution/mian-shi-ti-47-li-wu-de-zui-da-jie-zhi-dong-tai-gu/
来源:力扣(LeetCode)
动态规划:
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length;
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
if(i == 0 && j == 0) continue;
if(i == 0) grid[i][j] += grid[i][j - 1] ;
else if(j == 0) grid[i][j] += grid[i - 1][j];
else grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]);
}
}
return grid[m - 1][n - 1];
}
}
以上代码逻辑清晰,和转移方程直接对应,但仍可提升效率:当 grid 矩阵很大时, i=0 或 j = 0的情况仅占极少数,相当循环每轮都冗余了一次判断。因此,可先初始化矩阵第一行和第一列,再开始遍历递推。
class Solution {
public int maxValue(int[][] grid) {
int m = grid.length, n = grid[0].length;
for(int j = 1; j < n; j++) // 初始化第一行
grid[0][j] += grid[0][j - 1];
for(int i = 1; i < m; i++) // 初始化第一列
grid[i][0] += grid[i - 1][0];
for(int i = 1; i < m; i++)
for(int j = 1; j < n; j++)
grid[i][j] += Math.max(grid[i][j - 1], grid[i - 1][j]);
return grid[m - 1][n - 1];
}
}
总结
以上就是本题的内容和学习过程了,动态规划的题目首先应该想明白转移方程,而不是凭感觉就开始编程。
K神针滴强。
欢迎讨论,共同进步。