【leetcode-贪心】加油站/柠檬水找零/分发糖果/跳跃游戏/分发饼干/种花问题/非递减数列

文章目录

加油站
- 遍历+优化
- 找最小剩余量
柠檬水找零
- 贪心
分发糖果
- 贪心
- 一次遍历
跳跃游戏1
- 贪心法
跳跃游戏2
- 贪心算法
分发饼干
- 贪心
种花问题
- 贪心1
- 贪心2
非递减数列
- 贪心

加油站

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

说明:

如果题目有解，该答案即为唯一答案。
输入数组均为非空数组，且长度相同。
输入数组中的元素均为非负数。

示例 1:
输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。

示例 2:
输入:
gas = [2,3,4]
cost = [3,4,3]
输出: -1
解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

遍历+优化

若从 iii 出发无法到达 jjj 时，即iii到jjj的剩余汽油一定小于零，意味着 (i,j)(i,j)(i,j)中没有起始点kkk可以到达 jjj。因为lefti,j<0left_{i,j}<0lefti,j<0，lefti,k≥0left_{i,k}\geq0lefti,k≥0，所以leftk,j=lefti,j−lefti,k<0left_{k,j}=left_{i,j}-left_{i,k}<0leftk,j=lefti,j−lefti,k<0。

class Solution {public int canCompleteCircuit(int[] gas, int[] cost) {int len = gas.length;for(int i = 0, j = 0; i < len; i += j + 1) {int sumOfGas = 0, sumOfCost = 0;for (j = 0; j < len; j++) {int pos = (i + j) % len;sumOfGas += gas[pos];sumOfCost += cost[pos];if (sumOfCost > sumOfGas)break;}if (j >= len)return i;}return -1;}
}

找最小剩余量

class Solution {public int canCompleteCircuit(int[] gas, int[] cost) {int len = gas.length;int spare = 0;int minSpare = Integer.MAX_VALUE;int minIndex = 0;for (int i = 0; i < len; i++) {spare += gas[i] - cost[i];if (spare < minSpare) {minSpare = spare;minIndex = i;}}return spare < 0 ? -1 : (minIndex + 1) % len;}
}

柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。
顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：
输入：[5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

示例 2：
输入：[5,5,10]
输出：true

示例 3：
输入：[10,10]
输出：false

示例 4：
输入：[5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。

贪心

class Solution {public boolean lemonadeChange(int[] bills) {int count5 = 0, count10 = 0;for (int bill : bills) {if (bill == 5) {count5++;} else if (bill == 10) {if (count5 == 0)return false;count5--;count10++;} else {if (count10 > 0 && count5 > 0) {count5--;count10--;} else if (count10 == 0 && count5 > 3) {count5 -= 3;} else {return false;}}}return true;}
}

分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
你需要按照以下要求，帮助老师给这些孩子分发糖果：
每个孩子至少分配到 1 个糖果。
评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1：
输入：[1,0,2]
输出：5
解释：你可以分别给这三个孩子分发 2、1、2 颗糖果。

示例 2：
输入：[1,2,2]
输出：4
解释：你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

贪心

分别处理。
左规则：当 ratings[i−1]<ratings[i]\textit{ratings}[i - 1] < \textit{ratings}[i]ratings[i−1]<ratings[i] 时，i 号学生的糖果数量将比 i - 1 号孩子的糖果数量多。
右规则：当 ratings[i]>ratings[i+1]\textit{ratings}[i] > \textit{ratings}[i + 1]ratings[i]>ratings[i+1] 时，i 号学生的糖果数量将比 i + 1 号孩子的糖果数量多。

class Solution {public int candy(int[] ratings) {int len = ratings.length;int[] nums = new int[len];for (int i = 0; i < len; i++) {if (i > 0 && ratings[i] > ratings[i - 1])nums[i] = nums[i - 1] + 1;elsenums[i] = 1;}int num = 0, total = 0;for (int i = len - 1; i >= 0; i--) {if (i < len - 1 && ratings[i] > ratings[i + 1])num++;elsenum = 1;total += Math.max(nums[i], num);}return total;}
}

一次遍历

当前同学比上一个同学评分高，说明我们就在最近的递增序列中，直接分配给该同学 pre+1\textit{pre} + 1pre+1 个糖果即可。
否则我们就在一个递减序列中，我们直接分配给当前同学一个糖果，并把该同学所在的递减序列中所有的同学都再多分配一个糖果，以保证糖果数量还是满足条件。

class Solution {public int candy(int[] ratings) {int len = ratings.length;int total = 1;int inc = 1, dec = 0, pre = 1;for (int i = 1; i < len; i++) {if (ratings[i] >= ratings[i - 1]) {dec = 0;pre = ratings[i] == ratings[i - 1] ? 1 : pre + 1;total += pre;inc = pre;} else {dec++;if (dec == inc)dec++;total += dec;pre = 1;}}return total;}
}

跳跃游戏1

给定一个非负整数数组 nums ，你最初位于数组的第一个下标。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：
输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ，所以永远不可能到达最后一个下标。

贪心法

public class Solution {public boolean canJump(int[] nums) {int len = nums.length;int max_far = 0;for (int i = 0; i < len; ++i) {if (i <= max_far) {max_far = Math.max(max_far, i + nums[i]);if (max_far >= len - 1)return true;}}return false;}
}

跳跃游戏2

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:
输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

贪心算法

class Solution {public int jump(int[] nums) {int steps = 0;   // 跳跃次数int max_far = 0; // 目前能跳到的最远位置int end = 0;     // 上次跳跃可达范围右边界（下次的最右起跳点）for (int i = 0; i < nums.length - 1; i++) {max_far = Math.max(max_far, i + nums[i]);if (i == end) {  // 到达上次跳跃能到达的右边界了end = max_far;  // 目前能跳到的最远位置变成了下次起跳位置的有边界steps++;        // 进入下一次跳跃}}return steps;}
}

分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

示例 1:
输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:
输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

贪心

class Solution {public int findContentChildren(int[] g, int[] s) {Arrays.sort(g);Arrays.sort(s);int count = 0;int gLen = g.length, sLen = s.length;for (int i = 0, j = 0; i < gLen && j < sLen; i++, j++) {while (j < sLen && s[j] < g[i])j++;if (j < sLen)count++;}return count;}
}

种花问题

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

示例 1：
输入：flowerbed = [1,0,0,0,1], n = 1
输出：true

示例 2：
输入：flowerbed = [1,0,0,0,1], n = 2
输出：false

贪心1

记录上一个有花的格子索引，计算两花之间最多能种的数目。

class Solution {public boolean canPlaceFlowers(int[] flowerbed, int n) {int len = flowerbed.length;if ((len + 1) / 2 < n)return false;int count = 0, prev = -2;for (int i = 0; i < len; i++) {if (flowerbed[i] == 1) {count += (i - prev - 2) / 2;if (count >= n) return true;prev = i;}}count += (len - prev - 1) / 2;return count >= n;}
}

贪心2

类似跳格子的方法

class Solution {public boolean canPlaceFlowers(int[] flowerbed, int n) {int len = flowerbed.length;if ((len + 1) / 2 < n)return false;for (int i = 0; i < len && n > 0;) {if (flowerbed[i] == 1) {i += 2;} else if (i == len - 1 || flowerbed[i + 1] == 0) {n--;i += 2;} else {i += 3;}}return n <= 0;}
}

非递减数列

给你一个长度为 n 的整数数组，请你判断在最多改变 1 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的：对于数组中任意的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。

示例 1:
输入: nums = [4,2,3]
输出: true
解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

示例 2:
输入: nums = [4,2,1]
输出: false
解释: 你不能在只改变一个元素的情况下将其变为非递减数列。

贪心

存在两种情况

class Solution {public boolean checkPossibility(int[] nums) {int len = nums.length;int count = 0;for (int i = 0; i < len - 1; i++) {if (nums[i] > nums[i + 1]) {if (count++ != 0)return false;if (i > 0 && nums[i + 1] < nums[i - 1])nums[i + 1] = nums[i];}}return true;}
}