5.数的范围

1.题目

给定一个按照升序排列的长度为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

2.解题

二分法：

整数二分：有单调性一定可以二分，但可以二分的不一定具有单调性

寻找边界

（1）

mid=(l + r + 1)/2

if(check(mid) == true) [mid,r],l = mid

if(check(mid) == false) [l,mid - 1],r = mid - 1

（2）

mid = (l + r) / 2

if(check(mid) == true) [l,mid],r = mid

if(check(mid) == false) [mid + 1,r],l = mid + 1

方法一：

c++：

#include <iostream>

using namespace std;

int main()
{
    int n = 5, m = 3;
    int q[] = {1, 2, 2, 3, 3, 4};
    int x = 0;
    while (m--)
    {
        cin >> x;

        // 查找左边界
        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = (l + r) / 2;
            if (q[mid] >= x)
                r = mid;
            else
                l = mid + 1;
        }

        if (q[l] != x)
            cout << "-1 -1" << endl;
        else
        {
            cout << l << " ";

            // 查找右边界
            int l = 0, r = n - 1;
            while (l < r)
            {
                int mid = (l + r + 1) / 2;
                if (q[mid] <= x)
                    l = mid;
                else
                    r = mid - 1;
            }

            cout << l << endl;
        }
    }
    return 0;
}

java：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class rangeOfNums {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] string = in.readLine().split(" ");
        int n = Integer.parseInt(string[0]), q = Integer.parseInt(string[1]);
        int[] arr = new int[n];

        String[] str = in.readLine().split(" ");
        for (int i = 0; i < n; i++)
            arr[i] = Integer.parseInt(str[i]);

        for (int i = 0; i < q; i++) {
            int k = Integer.parseInt(in.readLine());
            int l = 0, r = n - 1;
            // 查找左边界
            while (l < r) {
                int mid = (l + r) / 2;
                if (arr[mid] >= k) {
                    r = mid;
                } else {
                    l = mid + 1;
                }
            }
            if (arr[l] != k)
                System.out.print("-1 -1\n");
            else {
                System.out.print(l);
                l = 0;
                r = n - 1;
                // 查找右边界
                while (l < r) {
                    int mid = (l + r + 1) / 2;
                    if (arr[mid] <= k) {
                        l = mid;
                    } else {
                        r = mid - 1;
                    }
                }
                System.out.print(" " + l + "\n");
            }
        }
    }
}

注意：同样的方法，在ACWing中，使用BufferedReader可以通过，但用Scanner超出时间限制

方法二：

利用二分法找到目标值，然后再循环查找目标值左边和右边是否有跟目标值一样的值，从而确定左右边界。

超出时间限制

java：

import java.util.Scanner;

public class Main{
    public static int[] find(int arr[], int n, int k){
        int i = 0, j = n, mid = (i + j) / 2;;
        int[] res = {-1, -1};
        while(i < j){
            if(arr[mid] > k){
                j = mid - 1;
            }else if(arr[mid] < k){
                i = mid + 1;
            }else{
                break;
            }
            mid = (i + j) / 2;
        }
        i = mid;
        j = mid;
        while(i >= 0 && arr[i] == k){
            i--;
            res[0] = i + 1;
        }
        while(j <= n && arr[j] == k){
            j++;
            res[1] = j - 1;
        }
        return res;
    }
    
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String s1 = scan.nextLine();
        int n = Integer.parseInt(s1.split(" ")[0]);
        int q = Integer.parseInt(s1.split(" ")[1]);
        int[] arr = new int[n];
        String[] s_arr = scan.nextLine().split(" ");
        for(int i = 0; i < n; i++){
            arr[i] = Integer.parseInt(s_arr[i]);
        }
        int[] res = new int[2];
        int k = 0;
        for(int i = 0; i < q; i++){
            k = Integer.parseInt(scan.nextLine());
            res = find(arr, n - 1, k);
            System.out.print(res[0] + " " + res[1] + "\n");
        }
    }
}

3.相关知识

Java中BufferedReader和scanner的对比

（1）BufferedReader

1.BufferedReader对象只将回车看作输入结束，得到的字符串；

2.BufferedReader是字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取！速度要比Scanner快！而且也可以设置缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

3.BufferedReader类位于java.io包中,所以要使用这个类,就要引入java.io这个包
import java.io.BufferedReader. readLine()方法会返回用户在按下Enter键之前的所有字符输入,不包括最后按下的Enter返回字符.使用BufferedReader对象的readLine()方法必须处理java.io.IOException异常(Exception).使用BufferedReader来取得输入,理解起来要复杂得多.但是使用这个方法是固定的,每次使用前先如法炮制就可以了

（2）Scanner

1.Scanner对象把回车,空格,tab键都看作输入结束，直接用sc.next()得到的是字符串形式

2.在创建Scanner类的对象时,需要用System.in作为它的参数,也可以将Scanner看作是System.in对象的支持者,System.in取得用户输入的内容后,交给Scanner来作一些处理.
Scanner类中提供了多个方法:
next():取得一个字符串;
nextInt():将取得的字符串转换成int类型的整数;
nextFloat():将取得的字符串转换成float型;
nextBoolean():将取得的字符串转换成boolean型;

3.Scanner类位于java.util包中,要加上import java.util.Scanner; 用Scanner获得用户的输入非常的方便,但是Scanner取得输入的依据是空格符,包括空格键,Tab键和Enter键.当按下这其中的任一键时,Scanner就会返回下一个输入.当你输入的内容中间包括空格时,显然,使用Scanner就不能完整的获得你输入的字符串.这时候我们可以考虑使用BufferedReader类取得输入.其实在Java SE 1.4及以前的版本中,尚没有提供Scanner方法,我们获得输入时也是使用BufferReader的.