贪心算法相关题目——NWU_LK

最新推荐文章于 2024-09-28 10:34:40 发布
最新推荐文章于 2024-09-28 10:34:40 发布
阅读量142 收藏
点赞数
分类专栏： leetcode 文章标签： 1024程序员节 leetcode 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NWU_LK/article/details/108791223
版权
  1. 柠檬水找零（860）
class Solution {
    public boolean lemonadeChange(int[] bills) {
        Map<Integer,Integer> moneys=new HashMap<>();
        for(int bill:bills){
            if (bill!=5){
                if (!zhaoQian(moneys,bill-5)){
                    return false;
                }
            }
            int x=moneys.getOrDefault(bill,0);
            moneys.put(bill,x+1);
        }
        return true;
    }
    public boolean zhaoQian(Map<Integer,Integer> map,int bill){
        Integer[] money = map.keySet().toArray(new Integer[map.size()]);
        Arrays.sort(money, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        for (Integer i:money){
            int count=map.getOrDefault(i,0);
            while (count>0 && bill>=i){
                map.put(i,map.get(i)-1);
                count--;
                bill-=i;
            }
        }
        if (bill!=0){
            return false;
        }
        return true;
    }
}
  1. 分发饼干（455题）
    在这里插入图片描述
class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int i=0,j=0;
        while (i<s.length&&j<g.length){
            if (s[i]>=g[j]){
                j++;
            }
            i++;
        }
        return j;
    }
}
  1. 摆动序列
    在这里插入图片描述
class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length<=1){
            return nums.length;
        }
        int prediff =nums[1]-nums[0];
        int count=prediff!=0?2:1;
        for (int i=2;i<nums.length;i++){
            int diff=nums[i]-nums[i-1];
            if ((prediff>=0&&diff<0)||(prediff<=0&&diff>0)){
                count++;
                prediff=diff;
            }
        }
        return count;
    }
}
  1. 删除k位数字（402题）
    在这里插入图片描述
class Solution {
    public String removeKdigits(String num, int k) {
       Stack<Integer> stack=new Stack<>();
        char[] chars=num.toCharArray();
        int count=0;
        for (char c:chars){
            int cha=c-'0';
            while (!stack.isEmpty()&&cha<stack.peek() && count<k){
                stack.pop();
                count++;
            }
            stack.push(cha);
        }
        while (count<k){
            stack.pop();
            count++;
        }
        
        Stack<Integer> stack1=new Stack<>();
        while (!stack.isEmpty()){
            stack1.push(stack.pop());
        }
        
        while (!stack1.isEmpty()&&stack1.peek()==0){
            stack1.pop();
        }
        if (stack1.isEmpty()){
            return String.valueOf(0);
        }
        StringBuilder sb=new StringBuilder();
        while (!stack1.isEmpty()){
            sb.append(stack1.pop());
        }
        return sb.toString();
    }
}
  1. 跳跃游戏
    在这里插入图片描述
class Solution {
    public boolean canJump(int[] nums){
        int k=0;
        for (int i=0;i<nums.length;i++){
            if (k<i){
                return false;
            }
            k=Math.max(i+nums[i],k);
        }
        return true;
    }
}
  1. 跳跃游戏2（45题）
    在这里插入图片描述
class Solution {
    public int jump(int[] nums) {
        int index=0;
        int count=0;
        while (index<nums.length-1){
            int x=nums[index];
            int min=1;
            for (int i=1;i<=x;i++){
                if (index+i>=nums.length-1){
                    return count+1;
                }
                if (i+nums[index+i]>=nums[index+min]+min){
                    min=i;
                }
            }
            index+=min;
            count++;
        }
        return count;
    }
}
  1. 用最少数量的箭引爆气球（452题）
    在这里插入图片描述
class Solution {
    public int findMinArrowShots(int[][] points) {
        int count=0,index=0;
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                long lo1=o1[1];
                long lo2=o2[1];
                if (lo1-lo2>0){
                    return 1;
                }else if (lo1-lo2==0){
                    return 0;
                }else {
                    return -1;
                }
            }
        });
        int[] pre=null;
        while (index<points.length){
            if (pre==null || points[index][0]>pre[1]){
                pre=points[index];
                count++;
            }
            index++;
        }

        return count;
    }
}
  1. 最低加油次数(871题)
    在这里插入图片描述
class Solution {
    public int minRefuelStops(int target, int startFuel, int[][] stations) {
        PriorityQueue<Integer> queue=new PriorityQueue<>((o1,o2)->o2-o1);
        int count=0;
        //max表示当前能够到达的最远距离
        int max=startFuel;
        if (max>target){
            return 0;
        }
        for (int[] station : stations) {
            int location=station[0];
            int capacity=station[1];
            //到不了该加油站则选择最大堆中油最多的一桶加油
            while (max<location){
                if (queue.isEmpty()){
                    return -1;
                }else {
                    max+=queue.poll();
                    count++;
                }
            }
            //将该加油站的油放入最大堆，供油不足时加油
            queue.offer(capacity);
        }
        //如果当前油量不足以到达终点则继续选择最大堆中的油加油
        while (max<target){
            if (queue.isEmpty()){
                return -1;
            }else {
                max+=queue.poll();
                count++;
            }
        }
        return count;
    }
}
  1. 非递增顺序的最小子序列（1403题）
    在这里插入图片描述
class Solution {
    public List<Integer> minSubsequence(int[] nums) {
        List<Integer> res= new ArrayList<>();
        Arrays.sort(nums);
        int sum=0;
        for(int num:nums){
            sum+=num;
        }
        int subSum=0;
        for (int i=nums.length-1;i>=0;i--){
            if (subSum<=sum/2){
                res.add(nums[i]);
                subSum+=nums[i];
            }
        }
        return res;
    }
}
  1. 最长快乐字符串（1405题）
    在这里插入图片描述
class Solution {
    public String longestDiverseString(int a, int b, int c) {
       StringBuilder sb=new StringBuilder();
        Map<Character,Integer> map=new HashMap<>();
        map.put('a',a);map.put('b',b);map.put('c',c);
        while (true){
            a=map.get('a');b=map.get('b');c=map.get('c');
            if (a>=b && a>=c){
                if (sb.length()<=1||!sb.substring(sb.length()-2).equals("aa")){
                    if (a==0) break;sb.append('a');map.put('a',a-1);
                }else{
                    if (b>=c){
                        if (b==0) break;
                        sb.append('b');map.put('b',b-1);
                    }else {
                        sb.append('c');map.put('c',c-1);
                    }
                }
            }
            else if (b>=a && b>=c){
                if (sb.length()<=1|| !sb.substring(sb.length()-2).equals("bb")){
                    sb.append('b');map.put('b',b-1);
                }else {
                    if (a>=c){
                        if (a==0) break;
                        sb.append('a');map.put('a',a-1);
                    }else {
                        sb.append('c');map.put('c',c-1);
                    }
                }
            }
            else{
                if (sb.length()<=1|| !sb.substring(sb.length()-2).equals("cc")){
                    sb.append('c');map.put('c',c-1);
                }else {
                    if (a>=b){
                        if (a==0) break;
                        sb.append('a');map.put('a',a-1);
                    }else {
                        sb.append('b');map.put('b',b-1);
                    }
                }
            }
        }
        return sb.toString();
    }
}
  1. 单调递增数字（738）
    在这里插入图片描述
class Solution {
    public int monotoneIncreasingDigits(int N) {
        char[] chars = String.valueOf(N).toCharArray();
        for (int i=chars.length-1;i>0;i--){
            if (chars[i]<chars[i-1]){
                chars[i-1]-=1;
                for (int j=i;j<chars.length;j++){
                    chars[j]='9';
                }
            }
        }
        return Integer.parseInt(new String(chars));
    }
}
  1. 最长递增子数列（300题）
    在这里插入图片描述
    求长度：
class Solution {
    public int lengthOfLIS(int[] arr) {
        if (arr.length==0){
            return 0;
        }
        int[] dp=new int[arr.length+1];
        int len=1;
        dp[len]=arr[0];
        for (int i=1;i<arr.length;i++){
            if (arr[i]>dp[len]){
                dp[++len]=arr[i];
            }else {
                int l=1,r=len,pos=0;
                while (l<=r){
                    int mid=l+(r-l)/2;
                    if (dp[mid]<arr[i]){
                        l=mid+1;
                        pos=mid;
                    }else {
                        r=mid-1;
                    }
                }
                dp[pos+1]=arr[i];
            }
        }
        return len;
    }
}

求数列：

public class Solution {
    public int[] LIS (int[] arr) {
        int[] dp=new int[arr.length+1];
        int[] tag=new int[arr.length];
        int len=1;tag[0]=1;
        dp[len]=arr[0];
        for (int i=1;i<arr.length;i++){
            if (arr[i]>dp[len]){
                dp[++len]=arr[i];
                tag[i]=len;
            }else {
                int l=1,r=len,pos=0;
                while (l<=r){
                    int mid=l+(r-l)/2;
                    if (dp[mid]<arr[i]){
                        l=mid+1;
                        pos=mid;
                    }else {
                        r=mid-1;
                    }
                }
                dp[pos+1]=arr[i];
                tag[i]=pos+1;
            }
        }
        int[] res = new int[len];
        for (int i = arr.length - 1; i >= 0; i--) {
            if (tag[i] == len) {
                res[--len] = arr[i];
            }
        }
        return res;
    }
}
课程表③

来源：Leetcode.630题

思想：尽量选择结束时间早的课程。首先对课程的结束时间进行排序，循环判断排序后的数组中的每一门课程，循环到某一门课程时判断前面课程花费的时间总和加上当前课程需要花费的时间是否小于等于当前课程的结束时间，如果满足的话则将其直接加入，不满足的话则判断当前课程是否可以替代前面花费时间比较长的课程，目的是尽量保证已学过的课程花费的时间较短，从而给后面的课程空余更多的时间。

class Solution {
    public int scheduleCourse(int[][] courses) {
        Arrays.sort(courses, (a, b) -> a[1] - b[1]);

        PriorityQueue<Integer> queue = new PriorityQueue<Integer>((a, b) -> b - a);
        // 优先队列中所有课程的总时间
        int total = 0;

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

        return queue.size();
    }
}
吃苹果的最大数目

来源：Leetcode.1705题

思想：按照贪心的思想，吃掉过期时间最早的果子。按照[过期时间,果子数量]的方式将其保存在优先队列（堆）里，按照过期时间排序，因此堆顶永远都是过期时间最早的果子。

public int eatenApples(int[] apples, int[] days) {
        int ans = 0;
        PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
        int n = apples.length;
        int i = 0;
        //遍历每天的果子数组
        while (i < n) {
        	//丢弃过期的果子
            while (!queue.isEmpty() && queue.peek()[0] <= i) {
                queue.poll();
            }
            int delayDay = i + days[i];
            int count = apples[i];
            if (count > 0) {
                queue.offer(new int[]{delayDay, count});
            }
            //将堆顶数目-1，如果为0则移除堆顶
            if (!queue.isEmpty()) {
                int[] arr = queue.peek();
                arr[1]--;
                if (arr[1] == 0) {
                    queue.poll();
                }
                ans++;
            }
            i++;
        }
        //如果堆中还有果子
        while (!queue.isEmpty()) {
        	//移除过期的
            while (!queue.isEmpty() && queue.peek()[0] <= i) {
                queue.poll();
            }
            if (queue.isEmpty()) {
                break;
            }
            //判断堆顶的果子可以吃几天
            int[] arr = queue.poll();
            int curr = Math.min(arr[0] - i, arr[1]);
            ans += curr;
            i += curr;
        }
        return ans;
    }
NWU_LK
关注
专栏目录
算法设计与分析：Minimum Number of Refueling Stops（Week 11）
c980129的博客
11-17 171
学号：16340008 题目：871. Minimum Number of Refueling Stops Question: A car travels from a starting position to a destination which is target miles east of the starting position. Along the way, there ar...
链表相关题目——NWU_LK
NWU_LK的博客
11-25 161
链表相关题目 反转链表2（92题） class Solution { public ListNode reverseBetween(ListNode head, int m, int n) { ListNode newHead=new ListNode(-1); newHead.next=head; ListNode p=newHead; //找到第 m个节点的前一个节点 for (int i=1;i<m;i
单调栈题目——NWU_LK
NWU_LK的博客
11-22 344
单调栈题目 柱状图中最大的矩形（84题） 分别用left和right数组记录当前元素左边与右边比自己大元素的最远距离（该距离是从当前元素出发的连续距离） class Solution { public int largestRectangleArea(int[] heights) { int[] left=new int[heights.length]; int[] right=new int[heights.length]; Stack<I
栈相关题目——NWU_LK
NWU_LK的博客
10-24 103
二叉树的后序遍历 class Solution { public List<Integer> postorderTraversal(TreeNode root) { List<Integer> res=new ArrayList<>(); Stack<TreeNode> stack=new Stack<>(); TreeNode p=root; TreeNode pre=.
动态规划相关题目——NWU_LK
NWU_LK的博客
09-18 202
动态规划相关题目 三角形最小路径和（120题） class Solution { public int minimumTotal(List<List<Integer>> triangle) { int n=triangle.size(); int[][] dp=new int[n][n]; dp[0][0]=triangle.get(0).get(0); for (int i=1;i<n;i++){
背包问题——NWU_LK
NWU_LK的博客
11-09 132
背包问题题目 0-1背包 即每个物品可以拿一次 分割等和子集（416题） class Solution { public boolean canPartition(int[] nums) { if (nums.length==0) return false; int sum=0,n=0; for (int num : nums) { sum+=num; } if (sum%2!=0) ret
Raft算法——NWU_LK
NWU_LK的博客
08-31 238
Raft算法 raft算法会先选举出leader，leader完全负责replicated log的管理。leader负责接受所有客户端更新请求，然后复制到follower节点，并在“安全”的时候执行这些请求。如果leader故障，followes会重新选举出新的leader。 这就涉及到raft最新的两个子问题： leader election和log replication。 raft中的角色 Raft将系统中的角色分为领导者（Leader）、跟从者（Follower）和候选者（Candidate）：
Java泛型——NWU_LK
NWU_LK的博客
04-11 466
目录泛型类和泛型接口泛型方法通配符的使用 泛型类和泛型接口 泛型标注在类名后边，例如 public class A<T> { public String Name; public T t; public A(String name,T t)P{ this.name=name; this.t=t; } } public static void main(String args[]){ A<String> aa = new A<>(); } 在实例化对象
Java日期——NWU_LK
NWU_LK的博客
01-25 249
时间类位置 java.time包下，都采用iso-8601标准 时间日期类 日期类LocalDate 时间类LocalTime 时间日期类：LocalDateTime 时间戳与间隔 Instant：获取时间戳 Duration：获取两个时期的间隔 Period：获取两个日期的间隔 时间矫正器 TemporalAdjuster：时间矫正器，用于获取某天的操作，比如下个周日，可以通过日期类的with方法传入。 LocalDateTime localDateTime=LocalDateTime.now();
Badminton_Hall_Appointment_Assistance__NWU羽毛球馆预约辅助_
09-02
Badminton_Hall_Appointment_Assistance__NWU羽毛球馆预约辅助NWU_BRS_assistant.zip_NWU_BRS_assistant
parallel_dbscan:基于NWU代码的并行dbscan的Python模块
05-05
并行dbscan是基于西北大学代码的Python打包的DBSCAN并行版本。 原始文件可以在这里找到： : 可以在parallel_dbscan / dbscan-v1.0.0中找到原始代码，其中包括原始软件包提供的所有内容，包括版权声明。
计算机网络基础——NWU_LK
NWU_LK的博客
10-03 1007
一.计算机网络的概述 计算机网络基本概念 互连的，自治的计算机集合 计算机网络主要功能 数据通信 资源共享 分布式处理 提高可靠性 负载均衡 计算机网络组成 按照功能可以分为：通信子网、资源子网 计算机网络分类 按照分布范围：广域网（WAN）、城域网（MAN）、局域网（LAN）、个人区域网（PAN） 按使用者分：公用网（移动、电信）、专用网（军用网等） 按交换技术分：电路交换、报文交换、分组交换 按拓扑结构分：总线型、星型、环形、网状型 按传播技术分：广播式网络、点对点网络 ...
NWU_ACM校赛题解+总结
Laj的博客
03-25 735
第一次参与ACM校赛的举办，紧张、激动又劳累。我本人主要负责PC2的搭建，具体搭配细节，请见另一篇博文： 虽然没有参加热身赛，但是在正式赛中还是作为普通选手参赛见识到了各个大佬的威力。本次比赛共5个小时，有16道题，包括三道C语言基础题和13道难度与区域赛相近的题。 A.模拟（C语言题） 题意：给流程图，模拟流程 题解：按照流程图的格式规范写循环或分支语句即可。 PS：题干描述不...
LeetCode 每日一题 2024/9/23-2024/9/29
最新发布
AlphaTao的博客
09-28 272
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 461
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
leetcode226. 翻转二叉树
Turboyiyi的博客
09-27 188
递归翻转二叉树
[leetcode]113_路径总和II_输出所有路径
weixin_45653183的博客
09-24 405
leetcode 的 Python 代码——处理输入输出；仅记录便于以后自查自学使用
C++速通LeetCode中等第25题-验证二叉搜索树（中序遍历堆栈迭代法）
lyx的博客
09-23 271
中序遍历堆栈迭代法
用Python写爬取西北大学教务系统的程序
05-22
我们可以通过模拟登录来获取相关信息。 下面是一个示例程序，可以爬取西北大学教务系统中的个人成绩信息： ```python import requests from bs4 import BeautifulSoup # 登录 session = requests.Session() login...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值