2020/9/29 Acwing-二分问题

题目描述

给定一个按照升序排列的长度为n的整数数组，以及 q 个查询。
对于每个查询，返回一个元素k的起始位置和终止位置（位置从0开始计数）。
如果数组中不存在该元素，则返回“-1 -1”。
输入格式
第一行包含整数n和q，表示数组长度和询问个数。
第二行包含n个整数（均在1~10000范围内），表示完整数组。
接下来q行，每行包含一个整数k，表示一个询问元素。
输出格式
共q行，每行包含两个整数，表示所求元素的起始位置和终止位置。
如果数组中不存在该元素，则返回“-1 -1”。
数据范围
1≤n≤100000
1≤q≤10000
1≤k≤10000
输入样例：
6 3
1 2 2 3 3 4
3
4
5
输出样例：
3 4
5 5
-1 -1

思路分析

本题题目要求使用二分法解决问题,二分法的使用范围是有序数组,核心思路是不断的二分区间,从而缩小范围,但是前提要保证要查找的目标一定在新划分的区间内部,因为只有这样才能在区间缩小到只有一个数时找到目标.

本题的解法我认为共分为了两大类,一类是递归的思想,一类是普通的思想. 就本题来说,可能普通思想会更加有效率,但是通过本题可以加深对递归的理解->也即是所有把想要实现的函数当做已经有的工具能解决的问题,都可以用递归算法解决.

递归解法

源代码

//使用递归实现二分

import java.util.Scanner;
import java.io.BufferedInputStream;
class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(new BufferedInputStream(System.in));
        int n=sc.nextInt();//数组长度
        int q=sc.nextInt();//询问个数
        int[] testq=new int[100100];
        for(int i=0;i<n;i++){
            testq[i]=sc.nextInt();
        }
        int[] qu=new int[100100];
        for(int i=0;i<q;i++){
            qu[i]=sc.nextInt();
        }
        for(int i=0;i<q;i++){
            System.out.print(bin_seek2(testq,0,n-1,qu[i])+" "+ bin_seek1(testq,0,n-1,qu[i]));
            System.out.println();
        }
    }
    static int bin_seek1(int[] q,int l,int r,int n){//目标:最后一个<=n的边界,返回角标
        if(l==r) 
        {if(q[l]==n)
            return l;
        else
            return -1;}
        
    
        int mid=l+r+1>>1;
        if(q[mid]<=n)//中间的数满足条件就往右找(不管左边有没有满足条件的)
           { 
            return bin_seek1(q,mid,r,n);}
        else{
            return bin_seek1(q,l,mid-1,n);
        }
      
        }
    static int bin_seek2(int[] q,int l,int r,int n){//目标:第一个满足>=n的边界,返回角标
        if(l==r) 
         {if(q[l]==n)
            return l;
        else
            return -1;}
        int mid=l+r>>1;
        if(q[mid]>=n)//中间的数满足条件就往左找(不管右边有没有满足条件的)
           { 
            return bin_seek2(q,l,mid,n);}
        else{
            return bin_seek2(q,mid+1,r,n);
        }
      
        }
    }
    
    

1. 大概想法是构造一个函数bin_seek2,能实现在传入数组和作用区间,以及目标值后,找到大于等于目标值的第一个数的角标;bin_seek1则是找到小于等于目标值的最后一个数的角标.如果没有找到,直接返回-1. 一下都以bin_seek2(找到大于等于目标值的第一个数的角标)为例
2. 在确定了函数功能后,接下来要把此函数作为已知工具.充分利用二分法的思想,比较数组中间的数与目标值,如果mid满足条件(大于等于目标值),那么区间缩小为l到mid(这里mid满足条件,一定要包扩mid),只需要利用函数工具改变参数即可;如果mid不满足条件,则区间缩小为mid+1到r,同样利用函数工具就直接得到结果了.
3. 最后不要忘记确定初始条件,因为区间在不断缩小,所以初始条件就是左右端点合二为一了,那么此时,区间内的唯一的数就是我们要找的数了,返回他的角标即可.如果区间内的数不是我们要找的数,返回-1.
   //注:当取(l~mid-1)作为边界时,mid的值应为(l+r+1)>>2,也就是多加了一个1,目的是为了防止出现无限循环的情况.

一般解法

源代码

//普通的二分法


import java.util.Scanner;
import java.io.BufferedInputStream;
class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(new BufferedInputStream(System.in));
        int n=sc.nextInt();//数组长度
        int q=sc.nextInt();//询问个数
        int[] testq=new int[100100];
        int l,r;
        for(int i=0;i<n;i++){
            testq[i]=sc.nextInt(); //创建数组
        }
        while(q-->0){
            int x=sc.nextInt();
             l=0;
             r=n-1;
            while(l<r){
                int mid=l+r>>1;
                if(testq[mid]>=x){//要找的条件 >=x
                    r=mid;
                }
                else 
                l=mid+1;
            }
            if(testq[l]!=x) System.out.println("-1 -1");
            else{
                System.out.print(l+" ");
            l=0;
            r=n-1;
            while(l<r){
                int mid=l+r+1>>1;
                if(testq[mid]<=x){//寻找最后一个小于等于x的角标(也就是向右找)
                    l=mid;
                }
                else
                r=mid-1;
            }
            System.out.println(l+" ");
            }
        }
    }
}

其实本质上跟递归法很近,唯一不同的是没有使用递归函数,而是直接操作原数组,通过不断移动指针l/r实现了区间的缩小.值得一提的是,因为题目是同时找第一个大于等于x,和最后一个小于等于x的,因此如果再找第一个的时候发现不存在,就不进入第二个寻找,直接输出"-1 -1",这样可以提高效率.
另外,再度提示了代码简洁化:如果要进行n次操作,而次数的标号并不重要,就使用while(n–>0)就好啦~用for反而会麻烦.

模板源代码

如果不用递归,但是仍然使用函数,那就可以使方法模块化,增加了复用性,下面是我写的模板代码:

    static int seek(int[] q,int l,int r,int x){//找大于等于x的第一个角标

        while(l<r){
            int mid=(l+r)>>1;
            if(q[mid]>=x){
                r=mid;
            }
            else{
                l=mid+1;
            }
        }
        if(q[l]==x) return l;
        else return -1;
    }

这类题其实很好做,只需要找到条件,并确定好是满足条件的第一个还是最后一个,(因为二分法就是能找到满足条件的第一个/最后一个数),就可以按照模板把代码写出了.
需要改动的点:
if语句内:写中间点满足条件的表达式
花括号内:根据是找第一个还是最后一个来为边界修改:

1. 第一个:则要左边–>r=mid
2. 最后一个:则要右边->l=mid-1
   如果只是要找满足条件的第一个/最后一个,到这里就可以结束了;但是如果要找目标值,就要把最后拿到的值与目标值比较(因为无论有没有目标值,算法都会找到一个值),香同没问题;不相同则要返回-1.
   举例:

1 2 3 3 5 5 7 9 //寻找6的角标

对于二分算法,其实可以设定找到的是大于等于6的第一个数的角标,本题找到的其实就是7,因为7!=6,所以返回-1;如果找到的是5呢?那么找到的其实就是第一个5(当然这是由于我们的设定),想找到第二个5的话自然要设定找到小于等于5的最后一个数啦.

最后贴上我在思考时写的记事本

二分法深度理解:
假如银行门口有很多人站在一起(n个人),每个人手里有的钱数都不相同,但是是有序的,钱少的在前,钱多的在后,那么此时就满足了二分法的条件–>整体分为两部分,一部分满足,一部分不满足,这样,我们就能找到到底是谁站在了两部分的交界处.
解这种题,
第一步:确认要求
到底想找哪个人? 答案:想找第一个满足小于1w元的人(当然了,我也可以找第一个大于1w元的或者最后一个大于1w元的等等,都是可以找到的,这里举其中一个为例)
第二步:分解要求
条件是:满足小于1w元
具体定位:找的是第一个(为什么说要找第1个呢?因为虽然范围会以/2的速度逐渐缩小,但是范围内一定会有要找的边界,但是很可能同一个数存在多个,边界虽然在小范围内,但是已经有部分(等值的数)被丢弃了,这就要我们在寻找的时候做取舍了),因此我们需要将范围向左取
伪代码: if(中间数满足条件(小于1w元)) 右端点改为mid
else 左端点改为 mid+1
同理,如果我们想找最后一个满足条件的,那么就需要将范围向右取
if(中间数满足条件) 左端点改为mid
else 右端点改为mid-1
注意,一旦出现mid-1,中间数角标的取值就应该从 (l+r)/2---->(l+r+1)/2
简言之,找第一个就往左取,找最后一个就忘右取;条件则在做提前通过逻辑确定. 所以逻辑确定到底是要大于(等于)还是小于(等于)是很重要的.