目录
以下摘自leetcode Top100精选题目-贪心算法篇
买卖股票的最佳时机
给定一个数组 prices
,它的第 i
个元素 prices[i]
表示一支给定股票第 i
天的价格。
你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0
。
示例:
输入:[7,1,5,3,6,4]
输出:5
解释:在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格;同时,你不能在买入前卖出股票。
输入:prices = [7,6,4,3,1]
输出:0
解释:在这种情况下, 没有交易完成, 所以最大利润为 0。
Solution:
经典的动态规划问题,可以使用一个变量来跟踪到目前为止遇到的最低价格,用当前的价格减去这个最低价格,得到的差值就是到目前为止的最大利润。
class Solution {
public int maxProfit(int[] prices) {
// 初始化最大利润为0,最低价格为数组的第一个元素
int maxprofit = 0, minprice = prices[0];
// 遍历价格数组
for (int price : prices) {
// 更新最低价格,如果当前价格小于最低价格,那么最低价格就变为当前价格
minprice = Math.min(minprice, price);
// 计算当前价格和最低价格的差值,如果这个差值大于最大利润,那么最大利润就变为这个差值
maxprofit = Math.max(maxprofit, price - minprice);
}
// 返回最大利润
return maxprofit;
}
}
先初始化最大利润maxprofit
为0,最低价格minprice
为价格数组prices
的第一个元素。
遍历价格数组prices
中的每一个元素。对于每一个元素,更新最低价格minprice
,如果当前的价格price
小于最低价格minprice
,那么最低价格minprice
就变为当前的价格price
。
计算当前的价格price
和最低价格minprice
的差值,如果这个差值大于最大利润maxprofit
,那么最大利润maxprofit
就变为这个差值。
在遍历完价格数组prices
后,返回最大利润maxprofit
,就是买卖股票的最佳时机所能获取的最大利润。
跳跃游戏
给你一个非负整数数组 nums
,你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标,如果可以,返回 true
;否则,返回 false
。
示例:
输入:nums = [2,3,1,1,4]
输出:true
解释:可以先跳 1 步,从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
Solution:
典型的贪心算法问题,可以通过维护一个变量来跟踪到目前为止能达到的最远位置,遍历数组,不断更新这个变量。
class Solution {
public boolean canJump(int[] nums) {
// 初始化最远能到达的位置为0
int maxPos = 0;
// 遍历数组
for (int i = 0; i < nums.length; i++) {
// 如果当前位置小于最远能到达的位置,说明可以从前面的位置跳到当前位置
if (i <= maxPos) {
// 更新最远能到达的位置
maxPos = Math.max(maxPos, i + nums[i]);
// 如果最远能到达的位置大于等于数组的最后一个位置,说明可以跳到最后一个位置
if (maxPos >= nums.length - 1) {
return true;
}
}
}
// 如果遍历完数组后,最远能到达的位置仍然小于数组的最后一个位置,说明无法跳到最后一个位置
return false;
}
}
先初始化最远能到达的位置maxPos
为0。
遍历数组nums
中的每一个元素。对于每一个元素,如果当前位置i
小于最远能到达的位置maxPos
,说明可以从前面的位置跳到当前位置i
。
更新最远能到达的位置maxPos
,如果当前位置i
加上当前位置的值nums[i]
大于最远能到达的位置maxPos
,那么最远能到达的位置maxPos
就变为当前位置i
加上当前位置的值nums[i]
。
如果最远能到达的位置maxPos
大于等于数组的最后一个位置,说明可以跳到最后一个位置,返回true
。
如果遍历完数组nums
后,最远能到达的位置maxPos
仍然小于数组的最后一个位置,说明无法跳到最后一个位置,返回false
。
跳跃游戏 II
给定一个长度为 n
的 0 索引整数数组 nums
。初始位置为 nums[0]
。
每个元素 nums[i]
表示从索引 i
向前跳转的最大长度。换句话说,如果你在 nums[i]
处,你可以跳转到任意 nums[i + j]
处:
0 <= j <= nums[i]
i + j < n
返回到达 nums[n - 1]
的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]
。
示例:
输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。
输入: nums = [2,3,0,1,4]
输出: 2
Solution:
public int jump(int[] nums) {
int step = 0; // 当前已经走过的步数
int curEnd = 0; // 当前这一步能够达到的最远位置
int maxReach = 0; // 当前能够达到的最远位置
for (int i = 0; i < nums.length - 1; i++) {
// 更新能够达到的最远位置
maxReach = Math.max(maxReach, i + nums[i]);
// 如果当前位置小于等于curEnd,则说明我们可以从某个位置跳到当前位置
if (i == curEnd) {
step++;
curEnd = maxReach;
}
}
return step;
}
- 初始化两个变量
step
和maxReach
,分别表示当前已经走过的步数和当前能够达到的最远位置。 - 使用一个变量
curEnd
来记录当前这一步能够达到的最远位置。 - 遍历整个数组,在遍历过程中,如果当前位置
i
小于等于curEnd
,则说明可以从某个位置跳到当前位置。更新maxReach
,即maxReach = max(maxReach, i + nums[i])
,表示我们能够达到的最远位置。 - 如果
curEnd < maxReach
,则说明需要再跳一步才能到达maxReach
这个位置,将step
加一,并且将curEnd
更新为maxReach
。 - 如果
maxReach >= n - 1
,则能够到达最后一个位置,直接返回step
即可。
划分字母区间
给你一个字符串 s
。我们要把这个字符串划分为尽可能多的片段,同一字母最多出现在一个片段中。
注意,划分结果需要满足:将所有划分结果按顺序连接,得到的字符串仍然是 s
。
返回一个表示每个字符串片段的长度的列表。
示例:
输入:s = "ababcbacadefegdehijhklij"
输出:[9,7,8]
解释:
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的,因为划分的片段数较少。
Solution:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class LetterGroupSplitter {
/**
* 划分字母区间
* @param s 待划分的字符串
* @return 区间的长度列表
*/
public List<Integer> partitionLabels(String s) {
// 记录每个字符最后一次出现的位置
int[] lastPositions = new int[26];
for (int i = 0; i < s.length(); i++) {
lastPositions[s.charAt(i) - 'a'] = i;
}
// 初始化当前区间的起始位置和上一个区间的结束位置
int start = 0, end = 0;
List<Integer> result = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
// 更新当前字符最后一次出现的位置
end = Math.max(end, lastPositions[s.charAt(i) - 'a']);
// 如果当前字符是区间的结束字符,那么就可以分割出一个子串
if (i == end) {
result.add(end - start + 1);
start = end + 1;
}
}
return result;
}
public static void main(String[] args) {
LetterGroupSplitter splitter = new LetterGroupSplitter();
String s = "ababcbacadefegdehijhklij";
System.out.println(Arrays.toString(splitter.partitionLabels(s).toArray()));
// Expected output: [9, 7, 8]
}
}
先遍历字符串 s
,记录每个字符最后一次出现的位置。再次遍历 s
,维护一个当前区间的结束位置 end
,当遍历到的位置等于 end
时,说明当前区间可以被分割,将这个区间的长度加入结果列表,并更新下一个区间的起始位置,返回结果列表。