算法学习———贪心算法（Java版）

最新推荐文章于 2024-05-28 09:55:51 发布

Sensen.

最新推荐文章于 2024-05-28 09:55:51 发布

阅读量1.7k

点赞数 5

文章标签：贪心算法学习算法

本文链接：https://blog.csdn.net/Sencq/article/details/127151124

版权

leetcode本周刷题路线：

贪心算法：通过实现部分最优解从而达到整体最优

455. 分发饼干（简单）：

题目描述：

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

示例：

你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。

所以你应该输出1。

解题思路：

分别将孩子的胃口值和饼干的尺寸进行排序，从尺寸最小的饼干开始判断能否把当前胃口值最小的孩子喂饱，若喂得饱就用下一块饼干喂下一个孩子，若喂不饱就换下一块更大的饼干来判断是否能喂饱当前孩子，直至饼干吃完或者孩子喂饱。

解题代码：

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int count = 0;
        int length_s = s.length;
        int length_g = g.length;
        Arrays.sort(g);
        Arrays.sort(s);
        for(int i = 0; i < length_s; i ++){
            if(s[i] >= g[count]){
                count ++;
            }
            if(count == length_g)
            break;
        }
        return count;
    }
}

376. 摆动序列（中等）：

题目描述：

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

示例：

例如， [1, 7, 4, 9, 2, 5] 是一个摆动序列，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。
相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

解题思路：

将摆动数列连续数字之间差的正负交换分别看作波峰和波谷。

设置两个整型变量 up、down，都用于记录摆动序列当前的状态，它们的值代表当前状态下摆动数列的长度。由于两个数字之间才会有一个波峰或波谷，因此 up 和 down 初值赋为 1。如果波峰（波谷）出现在波谷（波峰）之后，则波峰（波谷）值在上一个波谷（波峰）值基础上加 1，以此类推，直至遍历完数组中所有元素，比较 up 和 down 值的大小并返回最大值，这个值即为摆动数列的长度。

解题代码：

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int up = 1, down = 1;
        int length = nums.length;
        if(length < 2)
            return length;
        for(int i = 1; i < length; i ++){
            if(nums[i] > nums[i - 1])
                up = down + 1;
            if(nums[i] < nums[i - 1])
                down = up + 1;
        }
        return Math.max(up, down);
    }
}

53. 最大字数组和（中等）：

题目描述：

给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]

输出：6

解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

解题思路：

设置变量 sum、maxarr，sum 用于记录子数组的和，maxarr 用于记录子数组的最大值。从数组第一位开始遍历，每遍历一位就将当前值加入 sum，若添加之后 sum 小于零，则 sum 的值等于数组中下一个大于零的值。每遍历一个元素就将 sum 的值和 maxarr 当前的值比较，若 sum 的值大于 maxarr 的值则 maxarr 获得 sum 的值；反之，maxarr 的值不变。遍历结束 maxarr 的值即为子数组的最大和。

解题代码：

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = 0, maxarr = nums[0];
        for(int num : nums){
            if(sum > 0)
                sum += num;
            else 
                sum = num;
            maxarr = Math.max(maxarr, sum);
        }
        return maxarr;
    }
}

122.买卖股票的最佳时机 II（中等）：

题目描述：

给你一个整数数组 prices，其中 prices[ i ] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。

返回你能获得的最大利润。

示例：

                输入：prices = [7,1,5,3,6,4]
                输出：7
                解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出,          这笔交易所能获得利润 = 5 - 1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
              总利润为 4 + 3 = 7 。

解题思路：

该题解题思路与摆动序列有些许共同之处，差别在于 up 和 down 用于记录的是元素索引，且每次遍历时 up 和 down 的值都为上一元素的索引，主要思想是累加当前元素比前一元素大时她们之间的差值，数组遍历结束所得的差值之和即为所能获得的最大利润。

解题代码：

class Solution {
    public int maxProfit(int[] prices) {
        int up = 0, down = 0;
        int sum = 0, maxsum = 0;;
        int length = prices.length;
        for(int i = 1; i < length; i ++){
            if(prices[i] > prices[i - 1])
                up = down + 1;
            else if(prices[i] < prices[i - 1])
                down = up + 1; 
            else{
                up += 1;
                down += 1;
            }
            if(up > down){
                sum = prices[up] - prices[down];
                maxsum += sum;
                down = up;
            }
            else if(up < down)
                up = down;   
        }
        return maxsum;
    }
}

45.跳跃游戏 II（中等）：

题目描述：

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

示例：

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

解题思路：

遍历数组元素，记录当前位置所能跳跃的距离和在这段距离之内的位置所能覆盖的最大距离（分别简称为当前覆盖距离和最大覆盖距离），对于数组种每一位置，有 2 种情况：

1. 当遍历到该位置当前覆盖距离的位置且最大覆盖距离还未能覆盖数组最后一个位置时，跳跃次数加一并更新当前覆盖距离为最大覆盖距离。

2. 当在该位置覆盖距离之内遍历时，最大覆盖距离已经将数组最后一个位置覆盖，说明再向前跳一次即可到达数组最后一个位置。

注意：由于可以随意分配所能跳跃的距离，因此每次跳跃的位置指的一个区间的某一位置，而不是一个确定的位置。

解题代码：

class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length == 0 || nums.length == 1) 
            return 0;
        int count = 0;
        int cover = 0;
        int cur = 0;
        int length = nums.length;
        for(int i = 0; i < length; i ++){
            cover = Math.max(cover, i + nums[i]);
            if(cover >= length - 1){
                count ++;
                break;
            }
            if(i == cur){
                cur = cover;
                count ++;
            }
        }
        return count;
    }
}

135. 分发糖果（困难）：

题目描述：

n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

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

                每个孩子至少分配到 1 个糖果。
                相邻两个孩子评分更高的孩子会获得更多的糖果。
        请你给每个孩子分发糖果，计算并返回需要准备的最少糖果数目。

示例：

        输入：ratings = [1,2,2]
        输出：4
        解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
                  第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

解题思路：

由于每个孩子分到的糖果受到左右孩子评分的影响，若每次左右同时考虑则一定会顾此失彼，因此要左右分开考虑。

1. 先考虑右孩子评分比左孩子高的情况，若右孩子比左孩子评分高，则右孩子比左孩子多分一个糖果，否则只分一个糖果。

2. 再考虑左孩子评分比右孩子高的情况，若左孩子评分高于右孩子，若当前左孩子糖果已经多余右孩子，则不用再多给一颗糖果，否则将左孩子的糖果变为比右孩子多一。

解题代码：

class Solution {
    public int candy(int[] ratings) {
        int length = ratings.length;
        int[] candy = new int[length];
        candy[0] = 1;
        int count = 0;
        for(int i = 1; i < length; i ++){
            if(ratings[i] > ratings[i - 1])
                candy[i] = candy[i - 1] + 1;
            else
                candy[i] = 1;
        }
        for(int i = length - 2; i >= 0; i --){
            if(ratings[i] > ratings[i + 1])
                candy[i] = Math.max(candy[i], candy[i + 1] + 1);
        }
        for(int i : candy)
            count += i;
        return count;
    }
}

968. 监控二叉树（困难）：

题目描述：

给定一个二叉树，我们在树的节点上安装摄像头。节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。计算监控树的所有节点所需的最小摄像头数量。

示例：

        输入：[0,0,null,0,null,0,null,null,0]
        输出：2
        解释：需要至少两个摄像头来监视树的所有节点。上图显示了摄像头放置的有效位置之一。

解题思路：

由于二叉树的特殊结构，自上而下分析难度较大，采用递归的方法从下而上分析会更加易于理解。

由题意可知每个节点有三种状态：

1. 需要被监控； 2. 安装了监控； 3. 已被监控；

三种状态的优先级依次为：1、2、3

即当某一结点的左右节点的返回状态分别为 1 和 2 时，优先执行状态 1 ，即设置当前节点状态为 2 ，将监控数量加 1 ，然后返回该状态给上一节点，以此类推，直到递归结束。由于根节点没有上一节点，因此当递归结束后的返回的状态为状态 2 ，需将监控数量加一。

解题代码：

状态 0、1、2 分别为：被监控、需要被监控、安装监控

/**
 * 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 {
    int count = 0;
    public int minCameraCover(TreeNode root) {
        if(root == null)
            return 0;
        if(search(root) == 1)
            count ++;
        return count;
        
    }
    public int search(TreeNode node){
        if(node == null)
            return 0;
        
        int left = bfs(node.left), right = bfs(node.right);
        if(left == 1 || right == 1){
            count ++;
            return 2;
        }
        else if(left == 2 || right == 2)
            return 0;
        else
            return 1;
    }
}

学习心得：

通过这一星期贪心算法的学习，给我的感受是，贪心算法的上限真的好高！即使学习了一星期，看到贪心算法题还是要花很多时间思考，而且大概率不能独立完成！说明要想真正理解贪心算法的内核，靠这些题目还远远不够，还需要自己私下多下一点功夫，多刷点题，见得多才会想得多。总的来说，这星期的收获还是很大的，有些题目的切入点是我从未见过的，例如跳跃游戏和糖果问题。刷完这些题明显感觉自己的思路拓宽了许多，能从以前从未有过的方向分析问题。

再接再厉吧！