leetcode(贪心算法专题)

1.导论

• 贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
• 一般解题步骤

将问题分解为若干个子问题
找出适合的贪心策略
求解每一个子问题的最优解
将局部最优解堆叠成全局最优解

2.编程题

2.1 455. 分发饼干

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

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

1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1

//大饼干先喂饱大胃口
class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int ig = g.length-1;
        int is = s.length-1;
        int ans = 0;
        while(ig>=0 && is>=0){
            if(s[is]>=g[ig]){
                ++ans;
                --is;
            }
            --ig;
        }
        return ans;
    }
}
//小饼干先喂饱小胃口
class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int ans = 0;
        int ig = 0;
        int is = 0;
        while(ig<g.length && is<s.length){
            if(s[is]>=g[ig]){
                ++ans;
                ++ig;
            }
            ++is;
        }
        return ans;
    }
}

2.2 376. 摆动序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。
1 <= nums.length <= 1000
0 <= nums[i] <= 1000

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length<=1) return nums.length;
        int prediff = 0;//记录前一对差值
        int curdiff = 0;//记录当前一对差值
        int ans = 1;//记录峰值个数，默认序列最右边有一个峰值
        for(int i=0;i<nums.length-1;++i){
            curdiff = nums[i+1]-nums[i];
            //出现峰值
            if((prediff<=0 && curdiff>0) ||(prediff>=0 && curdiff<0)){
                ++ans;
                prediff = curdiff;
            }
        }
        return ans;
    }
}

2.3 53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
1 <= nums.length <= 105
-104 <= nums[i] <= 104

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = Integer.MIN_VALUE;
        int count = 0;
        for(int i=0;i<nums.length;++i){
            count += nums[i];
            if(count > ans){
                ans = count;
            }

            //相当于重置最大子序列起始位置，因为遇到负数一定是拉低总和（贪心的体现）
            if(count < 0) count = 0;
        }
        return ans;
    }
}

2.4 122. 买卖股票的最佳时机 II

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

//将整体的利润拆分为每天的利润
class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0;
        for(int i=1;i<prices.length;++i){
            ans += Math.max(prices[i]-prices[i-1],0);
        }
        return ans;
    }
}

2.5 55. 跳跃游戏

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。
1 <= nums.length <= 3 * 104
0 <= nums[i] <= 105

class Solution {
    public boolean canJump(int[] nums) {
        int cover = 0;
        if(nums.length == 1) return true;
        for(int i=0;i<=cover;++i){
            cover = Math.max(i+nums[i],cover);//更新覆盖范围(贪心的体现，取最大覆盖范围)
            if(cover >= nums.length-1) return true;//说明可以覆盖到终点了
        }
        return false;
    }
}

2.6 45. 跳跃游戏 II

给你一个非负整数数组 nums ，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

假设你总是可以到达数组的最后一个位置。

1 <= nums.length <= 104
0 <= nums[i] <= 1000

class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1) return 0;
        int curLocation = 0;//当前覆盖最远距离下标
        int nextLocation = 0;//下一步覆盖最远距离下标
        int ans = 0;
        for(int i=0;i<nums.length;++i){
            nextLocation = Math.max(i+nums[i],nextLocation);//更新下一步覆盖最远距离下标
            if(i == curLocation){//遇到当前覆盖最远距离下标
                if(curLocation != nums.length-1){//如果当前覆盖最远距离下标不是终点
                    ++ans;//需要走下一步
                    curLocation = nextLocation;//更新当前覆盖最远距离下标
                    if(nextLocation >= nums.length-1){//下一步覆盖的范围可以到达终点，结束循环
                        break;
                    }
                }else{
                    break;//当前覆盖最远距离下标是集合终点，不用做++ans操作了，直接结束
                }
            }
        }
        return ans;
    }
}

class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1) return 0;
        int curLocation = 0;//当前覆盖最远距离下标
        int nextLocation = 0;//下一步覆盖最远距离下标
        int ans = 0;
        for(int i=0;i<nums.length-1;++i){//这里是小于nums.length-1;这里是关键所在
            nextLocation = Math.max(i+nums[i],nextLocation);//更新下一步覆盖最远距离下标
            if(i == curLocation){//遇到当前覆盖最远距离下标
                ++ans;//需要走下一步
                curLocation = nextLocation;//更新当前覆盖最远距离下标
            }
        }
        return ans;
    }
}

2.7 1005. K 次取反后最大化的数组和

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

以这种方式修改数组后，返回数组可能的最大和。
1 <= A.length <= 10000
1 <= K <= 10000
-100 <= A[i] <= 100

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        Arrays.sort(nums);
        for(int i=0;i<nums.length;++i){
            if(nums[i]<0 && k>0){//贪心：尽可能将绝对值大的负数变为正数
                nums[i] *= -1;
                --k;
            }
        }
        Arrays.sort(nums);
        if(k>0 && k%2 ==1) nums[0] *= -1;
        int ans = 0;
        for(int num : nums){
            ans += num;
        }
        return ans;
    }
}

2.8 134. 加油站

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

说明:

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

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int n= gas.length;
        int lack = 0;//缺的油
        int newStart = 0;//记录新的开始点
        int saveGas = 0;//剩的油
        for(int i=0;i<n;++i){
            saveGas += gas[i]-cost[i];
            if(saveGas<0){//说明不能到达下个加油站
                newStart = i+1;
                lack += -saveGas;
                saveGas = 0;//因为开始新的起点，所以剩余的油要清0
            }
        }
        return saveGas >= lack ? newStart : -1;
    }
}

2.9 135. 分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

class Solution {
    public int candy(int[] ratings) {
        int[] candy = new int[ratings.length];
        Arrays.fill(candy,1);

        //从前向后
        for(int i=1;i<ratings.length;++i){
            if(ratings[i]>ratings[i-1]){
                candy[i] = candy[i-1]+1;
            }
        }

        //从后向前
        for(int i=ratings.length-2;i>=0;--i){
            if(ratings[i]>ratings[i+1]){
                candy[i] = Math.max(candy[i],candy[i+1]+1);
            }
        }
        int result = 0;
        for(int num : candy){
            result += num;
        }
        return result;
    }
}

2.10 860. 柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int fiveCount = 0;
        int tenCount = 0;
        int twentyCount = 0;
        for(int bill : bills){
            if(bill == 5){
                ++fiveCount;
            }
            if(bill == 10){
                if(fiveCount < 0) return false;
                ++tenCount;
                --fiveCount;
            }
            if(bill == 20){
                if(fiveCount>0 && tenCount>0){
                    --fiveCount;
                    --tenCount;
                    ++twentyCount;
                }else if(fiveCount>=3){
                    fiveCount -= 3;
                    ++twentyCount;
                }else{
                    return false;
                }
            }
        }
        return true;
    }
}

2.11 406. 根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。
1 <= people.length <= 2000
0 <= hi <= 106
0 <= ki < people.length
题目数据确保队列可以被重建

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        //按照身高降序 k升序排列
        Arrays.sort(people,(o1,o2) -> o1[0] == o2[0] ? o1[1]-o2[1] :o2[0]-o1[0]);
        List<int[]> list = new ArrayList<>();
        for(int[] i : people){
            list.add(i[1],i);//排序后k值即为需要插入的位置
        }
        return list.toArray(new int[list.size()][]);
    }
}       

2.12 452. 用最少数量的箭引爆气球

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。
1 <= points.length <= 104
points[i].length == 2
-231 <= xstart < xend <= 231 - 1

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points,(o1,o2) -> Integer.compare(o1[0], o2[0]));//注意这里使用o1[0]-o2[0]可能会溢出
        int ans = 1;//points不为空至少需要一支箭
        for(int i=1;i<points.length;++i){
            if(points[i][0] > points[i-1][1]){//气球i和气球i-1不挨着
                ++ans;
            }else{//气球i和气球i-1挨着
                points[i][1] = Math.min(points[i-1][1],points[i][1]);//更新重叠气球最小右边界
            }
        }
        return ans;
    }
}

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points,(o1,o2) -> Integer.compare(o1[1], o2[1]));//按照右端点排序
        int ans = 1;
        int pre = points[0][1];
        for(int i=1;i<points.length;++i){
            if(points[i][0]>pre){
                ++ans;
                pre = points[i][1];
            }
        }
        return ans;
    }
}

2.13 435. 无重叠区间

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if(intervals.length == 0) return 0;
        Arrays.sort(intervals,(o1,o2) -> Integer.compare(o1[1],o2[1]));
        int count = 1;//记录不重叠的个数
        int pre = intervals[0][1];
        for(int i=1;i<intervals.length;++i){
            if(intervals[i][0]>=pre){
                ++count;
                pre = intervals[i][1];
            }
        }
        return intervals.length-count;
    }
}

2.14 763. 划分字母区间

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
S的长度在[1, 500]之间。
S只包含小写字母 ‘a’ 到 ‘z’ 。

class Solution {
    public List<Integer> partitionLabels(String s) {
        List<Integer> ans = new ArrayList<>();
        int[] maxLocation = new int[26];
        for(int i=0;i<s.length();++i){//统计每一个字符最后出现的位置
            char c = s.charAt(i);
            maxLocation[c-'a'] = i;
        }
        int left = 0;
        int right = 0;
        for(int i=0;i<s.length();++i){
            char c = s.charAt(i);
            right = Math.max(right,maxLocation[c-'a']);//找到之前字符最大出现位置
            if(right == i){//如果之前字符最大出现位置和下标相等，则为一个片段
                ans.add(right-left+1);
                left = i+1;//更新左边界
            }
        }
        return ans;
    }
}

2.15 56. 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(o1,o2) -> Integer.compare(o1[0],o2[0]));
        List<int[]> ans = new ArrayList<>();
        ans.add(intervals[0]);
        for(int i=1;i<intervals.length;++i){
            if(ans.get(ans.size()-1)[1]>=intervals[i][0]){//重叠，合并区间
                ans.get(ans.size()-1)[1] = Math.max(ans.get(ans.size()-1)[1],intervals[i][1]);
            }else{//不重叠，直接存入
                ans.add(intervals[i]);
            }
        }
        return ans.toArray(new int[ans.size()][]);
    }
}

2.16 738. 单调递增的数字

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）
N 是在 [0, 10^9] 范围内的一个整数。

class Solution {
    public int monotoneIncreasingDigits(int n) {
        char[] c = String.valueOf(n).toCharArray();
        int flag = c.length;//用来标记赋值9从哪里开始
        for(int i=c.length-1;i>0;--i){
            if(c[i-1]>c[i]){
                flag = i;
                c[i-1]--;
            }
        }
        for(int i=flag;i<c.length;++i){
            c[i] = '9';
        }
        return Integer.parseInt(new String(c));
    }
}

2.17 968. 监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。
给定树的节点数的范围是 [1, 1000]。
每个节点的值都是 0。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    /*
        0：该节点无覆盖
        1：该节点有摄像头
        2：该节点有覆盖
     */
    int ans = 0;
    public int minCameraCover(TreeNode root) {
        if(postorder(root) == 0){//根节点无覆盖，需要放置一个摄像头
            ++ans;
        }
        return ans;
    }
    private int postorder(TreeNode root){
        if(root == null) return 2;
        int left = postorder(root.left);//左节点状态
        int right = postorder(root.right);//右节点状态
        if(left == 2 && right == 2) return 0;
        if(left ==0 || right == 0) {
            ++ans;
            return 1;
        }
        if(left ==1 || right == 1) return 2;
        return -1;
    }
}

2.18 630. 课程表 III

这里有 n 门不同的在线课程，按从 1 到 n 编号。给你一个数组 courses ，其中 courses[i] = [durationi, lastDayi] 表示第 i 门课将会 持续 上 durationi 天课，并且必须在不晚于 lastDayi 的时候完成。

你的学期从第 1 天开始。且不能同时修读两门及两门以上的课程。

返回你最多可以修读的课程数目。

1 <= courses.length <= 104
1 <= durationi, lastDayi <= 104

/*
	贪心思想：
		按照课程的截止时间，进行升序排序
		先学时间比较紧迫的课，也就是截止时间比较靠前的课。
		当学着学着发现再学下一门课会超时时，我们优先抛弃前面持续时间最长的课，然后继续学习下一门课
*/
class Solution {
    public int scheduleCourse(int[][] courses) {

        //按照课程的截止时间，进行升序排序
        Arrays.sort(courses,(o1, o2) -> o1[1]-o2[1]);

        //大顶堆存储结果
        PriorityQueue<Integer> q = new PriorityQueue<>((o1, o2) -> o2 - o1);

        //优先队列中所有课程的总时间
        int total = 0;

        for (int[] course : courses) {
            int duration = course[0];
            int lastDay = course[1];
            if (total + duration <= lastDay) {
                total += duration;
                q.offer(duration);
            } else if (!q.isEmpty() && q.peek() > duration) {
                total -= q.poll() - duration;
                q.offer(duration);
            }
        }

        return q.size();

    }
}

2.19 2111. 使数组 K 递增的最少操作次数

给你一个下标从 0 开始包含 n 个正整数的数组 arr ，和一个正整数 k 。

如果对于每个满足 k <= i <= n-1 的下标 i ，都有 arr[i-k] <= arr[i] ，那么我们称 arr 是 K 递增 的。

比方说，arr = [4, 1, 5, 2, 6, 2] 对于 k = 2 是 K 递增的，因为：
arr[0] <= arr[2] (4 <= 5)
arr[1] <= arr[3] (1 <= 2)
arr[2] <= arr[4] (5 <= 6)
arr[3] <= arr[5] (2 <= 2)
但是，相同的数组 arr 对于 k = 1 不是 K 递增的（因为 arr[0] > arr[1]），对于 k = 3 也不是 K 递增的（因为 arr[0] > arr[3] ）。
每一次 操作 中，你可以选择一个下标 i 并将 arr[i] 改成任意 正整数。

请你返回对于给定的 k ，使数组变成 K 递增的 最少操作次数

1 <= arr.length <= 105
1 <= arr[i], k <= arr.length

class Solution {
    public int kIncreasing(int[] arr, int k) {
        /*
            本质上是对于每一个i（0≤i≤k）,数组arr的数组 arr 的子序列：
                arr[i],arr[i+k],arr[i+2k],⋯
            是单调递增的。

            求出每个序列的最长递增子序列

            结果 += 每个序列长度 - 每个序列的最长递增子序列
        */

        int n = arr.length;
        int ans = 0;
        for (int i = 0; i < k; ++i) {
            List<Integer> list = new ArrayList<>();
            for (int j = i; j < n; j += k) {
                list.add(arr[j]);
            }
            Integer[] nums = list.toArray(new Integer[list.size()]);
            int maxLength = lengthOfLIS(nums);
            ans += nums.length - maxLength;
        }
        return ans;

    }

    //贪心+二分查找
    //贪心：如果我们要使上升序列尽可能的长，则我们需要让序列上升的尽可能的慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小
    public int lengthOfLIS(Integer[] nums) {
        int len = 1;//记录最长上升子序列的长度
        int n= nums.length;
        if (n == 0) return 0;
        int[] dp = new int[n+1];//长度为i的最长上上升子序列的末尾元素的最小值
        dp[len] = nums[0];
        for (int i = 1; i < n; ++i) {
            if (nums[i] >= dp[len]) {
                dp[++len] = nums[i];
            } else {
                int l = 1, r = len, pos = 0;
                while (l <= r) {
                    int mid = (l+r) >> 1;
                    if (dp[mid] <= nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    } else {
                        r = mid - 1;
                    }
                }
                dp[pos + 1] = nums[i];
            }
        }
        return len;
    }
}