198. 打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。
每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 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
package y24m04d16.solution198;
public class Solution {
public int rob(int[] nums) {
int[] dp = new int[nums.length];
//表示路过i房子时的最大收益
if (nums.length == 1)return nums[0];
//没得选
dp[0] = nums[0];
dp[1] = Math.max(nums[0], nums[1]);
//二选一
if (nums.length == 2)
return dp[1];
//要在i房子选择偷窃需满足：
//在i-1房的收益>在i-2房的总收益+i房的收益
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];
}
}
Solution
509. 斐波那契数
斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。
示例 1：
输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1
示例 2：
输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2
示例 3：
输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3
public class Solution {
public static void main(String[] args) {
Solution solution = new Solution();
System.out.println(solution.fib(10));
}
/**
* @author XiSoil
* @date 2024/04/16 11:06
*执行分布用时0ms,击败的100.00%Java用户
*消耗内存分布39.38MB,击败的42.29%Java用户
**/
public int fib(int n) {
int[] f = {0, 1, 0};
if (n <= 1) return f[n];
for (int i = 2; i <= n; i++) {
f[2] = f[0] + f[1];
//System.out.println(f[0] + " " + f[1] + " "+ f[2]);
f[0] = f[1];
f[1] = f[2];
}
return f[2];
}
}
Solution
746. 使用最小花费爬楼梯
给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。
示例 1：
输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。
示例 2：
输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。
public class Solution {
public static void main(String[] args) {
int[] cost = {1, 100, 1, 1, 1, 100, 1, 1, 100, 1};
System.out.println(new Solution().minCostClimbingStairs(cost));
}
/**
* @author XiSoil
* @date 2024/04/16 11:34
* 执行分布用时0ms,击败的100.00%Java用户
* 消耗内存分布41.99MB,击败的90.00%Java用户
**/
public int minCostClimbingStairs(int[] cost) {
int[] minCost = new int[cost.length+1];
minCost[0] = 0;
minCost[1] = 0;
for(int i=2; i<=cost.length; i++){
minCost[i] = Math.min(minCost[i-1]+cost[i-1], minCost[i-2]+cost[i-2]);
}
return minCost[cost.length];
// 优化-通过滚动数组的思想将空间复杂度优化到O(1)
/* int left = 0;
int right = 0;
int minCost = 0;
for(int i=2; i<=cost.length; i++){
minCost = Math.min(right+cost[i-1], left+cost[i-2]);
left = right;
right = minCost;
}
return minCost;*/
}
}
Solution
三道题的思想都是典型的动态规划
标签：三则,下标,偷窃,nums,int,Solution,台阶,LeetCode From： https://www.cnblogs.com/xxaxf/p/18142027