算法语言：java
题目来源：acwing.789

题目描述

给定一个按照升序排列的长度为 的整数数组，以及 q 个查询。

对于每个查询，返回一个元素 kk 的起始位置和终止位置（位置从 0 开始计数）。

如果数组中不存在该元素，则返回 -1 -1。

输入格式

第一行包含整数 n 和 q，表示数组长度和询问个数。

第二行包含 n 个整数（均在 1∼100001∼10000 范围内），表示完整数组。

接下来 q 行，每行包含一个整数 kk，表示一个询问元素。

输出格式

共 q 行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回 -1 -1。

数据范围

1≤n≤1000001≤n≤100000
1≤q≤100001≤q≤10000
1≤k≤100001≤k≤10000

输入样例：

6 3
1 2 2 3 3 4
3
4
5

输出样例：

3 4
5 5
-1 -1

题解

五点七边的二分法

五点七边 二分法 红蓝区域边界法

l = -1,r = N
while(l+1 != r)
	m=(l+r)/2
	if IsBlue(m)
		l = m;
	else
		r = m
return l or r

第一个细节 l，r 边界问题

为什么 l 边界初始化为 -1？

如果数组从开始就是红色边界，那么就如果 l 边界初始化为0的话，那么就会错误，不会出现蓝色区域

同理为什么 r 边界初始化为 N而不是N-1 ?

整个数组如果从刚开始就是蓝色区域，那么 r边界定义为N-1 会处于蓝色区域内，就会出现错误，不会出现红色区域

第二个细节 m是否始终处于[0,N)以内

第三个细节，更新指针时，能不能写成l = m+1，r = m-1

第四个细节 代码会不会陷入死循环

流程

1. 确定分界线

2.建模，划分红蓝区域，确定IsBlue()

3. 确定返回l 还是 r

4. 套用算法模版

代码

import java.util.Scanner;

public class day0705_0 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int q = sc.nextInt();
        int arr[] = new int[n];
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        for(int j =0;j<q;j++){
            int temp = sc.nextInt();
            int res1 = binary_search1(arr,n,temp);
            int res2 = binary_search2(arr,n,temp);
            System.out.println(res1+" "+res2);
        }
    }
    public static boolean isBlue1(int num,int x){
        if(num < x ) return true;
        else return false;
    }
    public static int binary_search1(int [] arr,int len,int x){
        int l = -1,r = len;
        while(l+1<r){
            int mid = (l+r)>>1;
            if(isBlue1(arr[mid],x)){
                l = mid;
            }else{
                r = mid;
            }
        }
        if(r == len){
            return -1;
        }
        if(arr[r] == x) return r;
        else return -1;
    }
    public static int binary_search2(int []arr,int len,int x){
        int l =-1,r = len;
        while(l+1 <r){
            int mid = (l+r) >>1;
            if(isBlue2(arr[mid],x)){
                l = mid;
            }else{
                r = mid;
            }
        }
        if(l == -1){
            return -1;
        }
        if(arr[l] == x) return l;
        else return -1;
    }
    public static boolean isBlue2(int num,int x){
        if(num<=x) return true;
        else return false;
    }
}

优化后：

import java.util.Scanner;
public class day0705_0 {
    static int N = 100010;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int q = sc.nextInt();
        int arr[] = new int[N];
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
        }
        for(int j =0;j<q;j++){
            int temp = sc.nextInt();
            int res1 = binary_search1(arr,n,temp);
            if(res1 == -1){
                System.out.println(-1+" "+-1);
                continue;
            }
            int res2 = binary_search2(arr,n,temp);
            System.out.println(res1+" "+res2);
        }
    }
    public static int binary_search1(int [] arr,int len,int x){
        int l = -1,r = len;
        while(l+1<r){
            int mid = (l+r)>>1;
            if(arr[mid] <x){
                l = mid;
            }else{
                r = mid;
            }
        }
        if(r == len){
            return -1;
        }
        if(arr[r] == x) return r;
        else return -1;
    }
    public static int binary_search2(int []arr,int len,int x){
        int l =-1,r = len;
        while(l+1 <r){
            int mid = (l+r) >>1;
            if(arr[mid] <=x){
                l = mid;
            }else{
                r = mid;
            }
        }
        if(l == -1){
            return -1;
        }
        if(arr[l] == x) return l;
        else return -1;
    }
}