每日刷题记录（十六）
目录
- 第一题：爬楼梯
-
- 解题思路：
- 代码实现：
- 第二题：不同路径
-
- 解题思路：
- 代码实现：
- 第三题：三角形最小路径和
-
- 解题思路：
- 代码实现：
- 第四题：最大子数组和
-
- 解题思路：
- 代码实现：
- 第五题：打家劫舍
-
- 解题思路：
- 代码实现：
第一题：爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例 1：
输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
- 1 阶 + 1 阶
- 2 阶
示例 2：
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
- 1 阶 + 1 阶 + 1 阶
- 1 阶 + 2 阶
- 2 阶 + 1 阶
提示：
- 1 <= n <= 45
解题思路：
本题为斐波那契数列的变形，到达n阶楼梯的方法数就是斐波那契数列的第n+1项
代码实现：
class Solution {
public int climbStairs(int n) {
int[] arr = new int[n+1];
arr[0] = 1;
arr[1] = 1;
for(int i = 2;i <= n;i++) {
arr[i] = arr[i-1] + arr[i-2];
}
return arr[n];
}
}
第二题：不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？
示例 1：
输入：m = 3, n = 7
输出：28
示例 2：
输入：m = 3, n = 2
输出：3
解释： 从左上角开始，总共有 3 条路径可以到达右下角。
- 向右 -> 向下 -> 向下
- 向下 -> 向下 -> 向右
- 向下 -> 向右 -> 向下
示例 3：
输入：m = 7, n = 3
输出：28
示例 4：
输入：m = 3, n = 3
输出：6
提示：
- 1 <= m, n <= 100
- 题目数据保证答案小于等于 2 * 109
解题思路：
本题为简单的动态规划问题，动态规划转移方程：arr(i, j) = arr(i-1, j) + arr(i, j-1)，先将arr[i][0]和arr[0][j]初始化为1，然后根据转移方程求得arr[i][j]，返回arr[m-1][n-1]
代码实现：
class Solution {
public int uniquePaths(int m, int n) {
int[][] arr = new int[m][n];
for(int i = 0;i < m;i++) {
arr[i][0] = 1;
}
for(int i = 0;i < n;i++) {
arr[0][i] = 1;
}
for(int i = 1;i < m;i++) {
for(int j = 1; j < n;j++) {
arr[i][j] = arr[i-1][j] + arr[i][j-1];
}
}
return arr[m-1][n-1];
}
}
第三题：三角形最小路径和
给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
示例 1：
输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出：11
解释：如下面简图所示：
2
3 4
6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
示例 2：
输入：triangle = [[-10]]
输出：-10
提示：
- 1 <= triangle.length <= 200
- triangle[0].length == 1
- triangle[i].length == triangle[i - 1].length + 1
- -104 <= triangle[i][j] <= 104
解题思路：
我们用 f[i][j] 表示从三角形顶部走到位置 (i, j) 的最小路径和。这里的位置 (i,j) 指的是三角形中第 i 行第 j列（均从 0 开始编号）的位置。
由于每一步只能移动到下一行「相邻的节点」上，因此要想走到位置 (i,j) ，上一步就只能在位置 (i−1,j−1) 或者位置 (i−1,j) 。我们在这两个位置中选择一个路径和较小的来进行转移，状态转移方程为：
f[i][j] = min(f[i-1][j-1], f[i-1][j]) + c[i][j]
其中 c[i][j] 表示位置 (i,j) 对应的元素值。
注意第 i 行有 i+1 个元素，它们对应的 j 的范围为 [0, i] 。当 j=0 或 j=i 时，上述状态转移方程中有一些项是没有意义的。
- 当 j=0 时， f[i-1][j-1] 没有意义，因此状态转移方程为：
f[i][0] = f[i-1][0] + c[i][0] （即当我们在第 i 行的最左侧时，我们只能从第 i−1 行的最左侧移动过来） - 当 j=i 时， f[i-1][j] 没有意义，因此状态转移方程为：
f[i][i] = f[i-1][i-1] + c[i][i] （即当我们在第 i 行的最右侧时，我们只能从第 i-1 行的最右侧移动过来）
最终的答案即为 f[n-1][0] 到 f[n−1][n−1] 中的最小值，其中 n 是三角形的行数。
代码实现：
class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int min = Integer.MAX_VALUE;
int n = triangle.size();
int[][] f = new int[n][n];
f[0][0] = triangle.get(0).get(0);
for(int i = 1;i < n;i++) {
List<Integer> row = triangle.get(i);
for(int j = 0;j <= i;j++) {
if(j == 0) {
f[i][j] = f[i-1][j] + row.get(j);
} else if(j == i) {
f[i][j] = f[i-1][j-1] + row.get(j);
} else {
f[i][j] = Math.min(f[i-1][j],f[i-1][j-1]) + row.get(j);
}
}
}
for(int i = 0;i < n;i++) {
min = Math.min(min,f[n-1][i]);
}
return min;
}
}
第四题：最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1]
输出：1
示例 3：
输入：nums = [5,4,-1,7,8]
输出：23
提示：
- 1 <= nums.length <= 105
- -104 <= nums[i] <= 104
解题思路：
假设 nums 数组的长度是 n ，下标从 0 到 n−1。
我们用 dp(i) 代表以第 i 个数结尾的「连续子数组的最大和」，那么很显然我们要求的答案就是：
max(dp(0), dp(1), … , dp(n-1))
此时求 dp(i) 的值，需要分几种情况：
- 如果 i=0，则 dp(i)=nums[0] 。
- 如果 dp(i-1) > 0 ，说明第 i 个元素结束的连续子数组，是将 dp(i-1) 连续子数组和当前第 i 个元素连接起来组成
- 如果 dp(i-1) <=0 ，说明第 i 个元素结束的连续子数组，是由第 i 个元素组成，即只有这一个元素。
代码实现：
class Solution {
public int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];
dp[0] = nums[0];
for(int i = 1;i < nums.length;i++) {
if(dp[i-1] > 0) {
dp[i] = dp[i-1] + nums[i];
} else {
dp[i] = nums[i];
}
}
int max = Integer.MIN_VALUE;
for(int i = 0;i < dp.length;i++) {
max = Math.max(max,dp[i]);
}
return max;
}
}
第五题：打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
提示：
- 1 <= nums.length <= 100
- 0 <= nums[i] <= 400
解题思路：
本题为简单的动态规划问题，动态规划转移方程为dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1])
边界条件为
- dp[0] = nums[0];
- dp[1] = Math.max(nums[0],nums[1]);
代码实现：
class Solution {
public int rob(int[] nums) {
int n = nums.length;
if(n == 1) {
return nums[0];
}
int[] dp = new int[n];
dp[0] = nums[0];
dp[1] = Math.max(nums[0],nums[1]);
for(int i = 2;i < n;i++) {
dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
}
int max = Integer.MIN_VALUE;
for(int i = 0;i < n;i++) {
max = Math.max(max,dp[i]);
}
return max;
}
}