四十二、贪心——区间问题

最新推荐文章于 2024-05-24 21:55:03 发布
最新推荐文章于 2024-05-24 21:55:03 发布
阅读量331 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 数据结构 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46014180/article/details/131557255
版权

算法主要内容

一、贪心

  • 贪心问题思路：对于每种情况，都是选择当前最优，比较短视。
  • 只能解决单峰问题。
    在这里插入图片描述

二、区间选点问题

1、题目内容

在这里插入图片描述

2、算法思路

  • 区间贪心问题一般会先对区间进行排序
    • 左端点排序
    • 右端点排序

（1）图例

在这里插入图片描述

（2）算法步骤

  • 1、将每个区间按右端点从小到大排序。
  • 2、从前往后一次枚举每一个区间，如果当前区间中已经包含点，则直接pass，否则，选择当前区间的右端点。

3、题解

import java.util.*;
import java.io.*;

public class Main{
    static int N = 100010;
    static int n;


    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        String str1 = in.readLine();
        n = Integer.parseInt(str1);
        List<PIIs> list = new ArrayList<PIIs>();

        for(int i = 0; i < n; i++){
            String[] str2 = in.readLine().split(" ");
            int l = Integer.parseInt(str2[0]);
            int r = Integer.parseInt(str2[1]);
            list.add(new PIIs(l, r));
        }

        Collections.sort(list);             // 将区间按照右端点从小到大排序排序

        int count = 0;
        int end = Integer.MIN_VALUE;        // 初始化 所选点

        for(PIIs item:list){

            if(item.getFirst() > end){      // 也就是还没到本区间的左边，没在范围内，因此需要更新，增加点
                count++;
                end = item.getSecond();     // 新增加的点，直接选定右端点作为最优
            }
        }

        System.out.println(count);

    }
}

class PIIs implements Comparable<PIIs>{
    private int first;
    private int second;

    public PIIs(int first,int second){
        this.first = first;
        this.second = second;
    }

    public int getFirst(){
        return this.first;
    }

    public int getSecond(){
        return this.second;
    }

    public int compareTo(PIIs o){
        return Integer.compare(second, o.second);
    }


}

三、最大不相交区间数量

1、题目内容

在这里插入图片描述

2、算法思路

（1）状态划分

在这里插入图片描述

（2）步骤

    1. 将每一个区间按照右端点从小到大排序
    1. 从前向后依次排序每个区间，如果当前区间已经包含点，则直接pass，否则，选择当前区间的右端点。

（3）贪心证明

在这里插入图片描述

3、题解

import java.util.*;
import java.io.*;

public class Main{
    static int N = 100010;


    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        String str1 = in.readLine();
        int n = Integer.parseInt(str1);

        List<PIIs> list = new ArrayList<PIIs>();

        for(int i = 0; i < n; i++){
            String[] str2 = in.readLine().split(" ");
            int L = Integer.parseInt(str2[0]);
            int R = Integer.parseInt(str2[1]);

            list.add(new PIIs(L, R));
        }

        Collections.sort(list);

        int count = 0;
        int end = Integer.MIN_VALUE;

        for(PIIs item:list){
            if(item.getFirst() >end){
                count++;
                end = item.getSecond();
            }
        }

        System.out.println(count);


    }
}

class PIIs implements Comparable<PIIs>{
    private int first;
    private int second;

    public PIIs(int first, int second){
        this.first = first;
        this.second = second;
    }

    public int getFirst(){
        return this.first;
    }

    public int getSecond(){
        return this.second;
    }

    public int compareTo(PIIs o){
        return Integer.compare(second, o.second);
    }

}

四、区间分组问题

1、题目内容

在这里插入图片描述

2、算法思路

（1）状态划分

在这里插入图片描述

（2）算法步骤

    1. 将所有区间按照左端点从小到大排序
    1. 从前向后处理每个区间，判断能否能将其放入某个现有的组中，判断每个组区间的最后一个点是否与当前区间有交集，有则下一组。（L[i] > Max_R,L[i] <= Max_R则说明有交集）

（3）注意事项

在这里插入图片描述

3、题解

import java.util.*;
import java.io.*;

public class Main{
    static int N = 100010;
    
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        String str1 = in.readLine();
        int n = Integer.parseInt(str1);
        
        List<PIIs> list = new ArrayList<PIIs>();
        
        for(int i = 0; i < n; i++){
            String[] str2 = in.readLine().split(" ");
            int L = Integer.parseInt(str2[0]);
            int R = Integer.parseInt(str2[1]);
            
            list.add(new PIIs(L, R));
        }
        
        Collections.sort(list);
        
        Queue<Integer> queue = new PriorityQueue<Integer>();        
        // 存取各个组的右端点值（每个组中所有区间最右边的点）
        
        for(PIIs item:list){
            if(queue.isEmpty() || queue.peek() >= item.getFirst()){     
                // peek得到的是各组右端点最小值，是因为如果最小值都还有重叠，那就只能item单独开一个组
                queue.offer(item.getSecond());
            }else{
                queue.poll();       
                // 有不重叠的组，那也就可以加在这后面，但是新加的区间必定会更新组的右端点
                // 因为l是大于原来的右端点的
                queue.offer(item.getSecond());
            }
        }
        
        System.out.println(queue.size());
        
        
    }
}

class PIIs implements Comparable<PIIs>{
    private int first;
    private int second;
    
    public PIIs(int first, int second){
        this.first = first;
        this.second = second;
    }
    
    public int getFirst(){
        return this.first;
    }
    
    public int getSecond(){
        return this.second;
    }
    
    public int compareTo(PIIs o){
        return Integer.compare(first, o.first);         // 各个区间左端点排序
    }
    
}

五、区间覆盖

1、题目内容

在这里插入图片描述

2、算法步骤

1、状态划分

在这里插入图片描述

2、算法步骤

  • 1. 将所有区间按左端点，从小到大排序
  • 2. 从前往后一次枚举每个区间
    • （1）选择能将start覆盖，且右端点最大的区间
    • （2）选完之后，将start更新成右端点的最大值

3、题解

import java.util.*;
import java.io.*;

public class Main{
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        List<PIIs> list = new ArrayList<PIIs>();
        
        
        String[] str1 = in.readLine().split(" ");
        int st = Integer.parseInt(str1[0]);
        int ed = Integer.parseInt(str1[1]);
        
        String str2 = in.readLine();
        int n = Integer.parseInt(str2);
        
        for(int i = 0; i < n; i++){
            String[] str3 = in.readLine().split(" ");
            int L = Integer.parseInt(str3[0]);
            int R = Integer.parseInt(str3[1]);
            list.add(new PIIs(L, R));
        }
        
        Collections.sort(list);     //左端点排序
        int res = 0;                // 最终使用的区间个数
        
        boolean flag = false;       // 判断是否能把区间覆盖的标志
        
        for(int i = 0; i < n; i++){             //从第一个区间开始遍历，后面可能会跳过
            int j = i;                          // 当前查看的区间，看是否满足作为增加的区间
            int end = Integer.MIN_VALUE;        // 设置为最小值，当前已经选择区间的右端点
            while(j < n && list.get(j).getFirst() <= st){       
                // 判断-待选择区间-的左端点是否包含了-需要覆盖的剩余区间的左端点
                end = Math.max(end, list.get(j).getSecond());
                j++;
            }
            
            
            if(end < st){       //新增加的选择区间-的右端点没包含初始点，也就是根本够不到
                res = -1;
                break;
            }
            
            res++;              // 到这里说明增加了一个新的区间
            
            if(end >= ed){      // 全部覆盖，则调整标志
                flag = true;
                break;
            }
            
            st = end;           // 每选取一个区间，就将st赋值成这个区间的右端;
            i = j - 1;          
            // 然后将因为我们j是判断了所有的  ----第一个可以选的-----区间，
            // 所以将这些都不用看了，直接从j开始看，i= j，因为是从0开始的，所以就赋值成j - 1
            
        }
        
        
        if(!flag){
            System.out.println(-1);
        }else{
            System.out.println(res);
        }
        
    }
}


class PIIs implements Comparable<PIIs>{
    private int first;
    private int second;
    
    public PIIs(int first,int second){
        this.first = first;
        this.second = second;
    }
    
    public int getFirst(){
        return this.first;
    }
    
    public int getSecond(){
        return this.second;
    }
    
    public int compareTo(PIIs o){
        return Integer.compare(first, o.first);
    }
    
}
牙否
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【c++入门(2)】区间贪心
小学生蒟蒻
10-14 304
文档: 大纲 1.不相交区间 2.区间选点 1.不相交区间问题 贪心要素 贪心选择性质：问题的整体最优解可以通过一系列局部的最优选择得到。 最优子结构：当问题的最优解包含其子问题的最优解时称该问题具有最优子结构性质。 对贪心选择的证明，就是在证明贪心选择获得的局部最优解是全局最优解的一部分。 问题描述：给定????个半开区间 [???? ???? , ???? ???? )，选择尽量多个区间，使得这些区间两两没有公共点。 示例：N = 3，区间分别为：[1, 5), [2, 4)
贪心 区间覆盖
m0_53203911的博客
03-18 630
给定 N 个闭区间 [ai,bi] 以及一个线段区间 [s,t]，请你选择尽量少的区间，将指定线段区间完全覆盖。 输出最少区间数，如果无法完全覆盖则输出 −1。 输入格式 第一行包含两个整数 s 和 t，表示给定线段区间的两个端点。 第二行包含整数 N，表示给定区间数。 接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。 输出格式 输出一个整数，表示所需最少区间数。 如果无解，则输出 −1。 数据范围 1≤N≤105, −109≤ai≤bi≤109, −109≤s≤t≤109 输入样例：
贪心算法之区间问题详解
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
03-19 2613
目录 1.贪心算法简介 基本思想 局限性 2.经典例题 区间问题 贪心策略 3.代码 1.贪心算法简介 基本思想 1）贪婪算法（贪心算法）是指在对问题进行求解时，在每一步选择中都采取最好或者最优（即最有利）的选择，从而希望能够导致结果是最好或者最优的算法。 2）贪婪算法所得到的结果不一定是最优的结果（有时候会是最优解），但是都是相对近似（接近）最优解的结果。 局限性 贪心算法失效的很大一个原因在于它明显的局限性：它几乎只考虑局部最优解。 所谓局部最优，就是只考虑当前的最大利益，既
贪心算法--区间调度问题
最新发布
2301_79977698的博客
05-24 1115
在本文中，我们深入探讨了贪心算法的原理、应用场景以及实现方法。贪心算法作为一种简单而强大的算法设计技巧，已经在许多领域得到了广泛的应用，如图论、任务调度、最优化问题等。通过每一步的局部最优选择，贪心算法能够快速地找到问题的最优解，具有较高的执行效率。在实际应用中，贪心算法的灵活运用能够为我们带来更多的便利和效益。通过深入理解贪心算法的原理和特点，我们可以更好地利用这一算法工具，为解决实际问题提供有效的解决方案。希望本文能够帮助读者更好地理解贪心算法，并在实际应用中取得更好的效果。
第三十八章 贪心算法——区间问题（上）
Turing_Sheep的博客
01-02 1407
详解贪心策略中的区间问题的思路，代码和证明。
贪心算法专题小结——区间相关问题
weixin_67271870的博客
12-04 538
贪心算法是一种高效算法，可以快速得到问题的答案。如果一个问题可以用贪心法解决，那么它必须具备2条性质：1.具有最优子结构（即问题的最优解包含了子问题的最优解），2.具有贪心选择性质（即可以通过做出局部最优选择来构造全局最优）。下面总结一下基于贪心算法的区间问题。1.问题描述：数轴上有n个开区间(Ai,Bi)，选择尽量多个区间，使得这些区间两两没有公共点。样例输入：n=5, (1,3),(2,5),(4,7),(6,9),(8,10)。样例输出：3 (选择第1,3,5个区间)2.贪心策略：按照终点从小到大给区
算法学习系列（三十四）：区间问题（贪心）
weixin_60033897的博客
02-18 1246
这个区间问题其实是个贪心问题，说起这个贪心问题，其实没有什么套路模板可言，就是多做题，这道题你做过类似的，那么你就可以AC，否则都是空谈。所以该篇主要还是以例题为主进行讲解。
信息奥赛c++学习笔记——贪心算法
01-06
1.问题描述：给定n个开区间（ai，bi），在给定范围内尽量选择多个区间，使得这些区间两两没有公共点。 2.算法：按照结束时间bi从小到大排序，然后按照排序顺序依次考虑每个活动，如果没有和已选活动冲突，就选，否则...
C++ 贪心算法的 5 大问题模板与解析
07-08
内容简介： 涵盖 - 选择不相交区间问题 & - 区间覆盖问题 & ...五大贪心问题模板与解析。 适合人群： 普及晚期或提高早期的萌新 OIer 们。 （参考并整合自《信息学奥赛一本通——提高篇》）
贪心算法活动安排问题
12-03
对于活动安排问题，贪心算法`greedySelector`确实能找出最大的相容活动子集合，即找到可以同时进行的最大数量的活动，这得益于问题本身的特性——最优子结构和贪心选择性质。 最优子结构意味着一个问题的最优解可以...
十五类算法全集——经典算法
12-11
《十五类算法全集——经典算法》是一份深入学习计算机科学和编程的宝贵资源，它涵盖了从基础到高级的各种算法，旨在帮助初学者和有经验的程序员更好地理解和应用这些算法。算法是解决问题和优化计算过程的关键工具，...
贪心算法-计算机编程 数据结构
08-04
接着，我们看一个具体的问题——事件序列问题。给定N个事件，每个事件都有开始和结束的时间，目标是找到一个尽可能长的不冲突的事件序列。贪心策略是每次都选取结束最早的事件加入序列，因为如果存在一个更长的不...
贪心算法之区间问题总结
BAI20010904的博客
03-15 704
代码随想录笔记
贪心算法——区间问题
Psychosocial的博客
04-06 3456
区间选点问题 区间选单个点 问题描述： 数轴上有N个闭区间[Ai, Bi]。取尽量少的点，使得每个区间内都至少有一个点（不同区间内含的点可以是同一个）。 输入 第1行：一个整数N 接下来N行，每行2个整数Ai，Bi 输出 一个整数，表示满足条件的最少点数。 样例输入 5 4 6 2 3 1 4 6 8 5 7 【样例输出】 2 策略分析： 题目要求每个区间都至少有一个点，那么如果存在区间重...
区间选点
_lilian_的博客
03-06 945
题目要求 数轴上有 n 个闭区间 [a_i, b_i]。取尽量少的点，使得每个区间内都至少有一个点（不同区间内含的点可以是同一个） Input 第一行1个整数N（N<=100） 第2~N+1行，每行两个整数a,b（a,b<=100） Output 一个整数，代表选点的数目 Examples Input 2 1 5 4 6 Output 1 Input 3 1 3 2 5 4 ...
步步为营（四）贪心（3）区间选点问题
Kernight
07-23 1593
区间选点的问题大致可以描述为： 给定N个区间[a,b]，取尽量少的点，使得每个区间内都至少有一个点（不同区间内含的点可以重复）。关于贪心算法的验证过程就不再赘述，现在思考一下贪心策略的制定。 对于区间[a1, b1] 、[a2, b2]、 [a3, b3] 来说， 如果想选择最少的点，那么必须选择每个区间的右端点，示意图如下： 当你每一次都选择区间的最右端，才能保证每一个选的点覆盖的范围都是
贪心算法(区间问题)
shiboluobuding的博客
03-03 1845
有一些球形气球贴在一堵用 XY 平面表示的墙面上。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是。处射出一支箭，若有一个气球的直径的开始和结束坐标为。一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。给定一个二叉树，我们在树的节点上安装摄像头。你不知道气球的确切 y 坐标。计算监控树的所有节点所需的最小摄像头数量。返回一个表示每个字符串片段的长度的列表。请你合并所有重叠的区间，并返回。可以射出的弓箭的数量。
【笔记】贪心（1）---区间问题
kanawi的博客
01-13 419
贪心算法解决区间问题三步走
贪心算法实例：事件序列与区间覆盖问题详解
"本资源主要关注于计算机科学中的两个经典问题——贪心算法的应用实例，分别为事件序列问题和区间覆盖问题。贪心算法是一种解决问题的方法，它在每个步骤中都采取在当前看来是最好的选择，但并不保证一定能得到全局...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牙否

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值