二分法运用-数的范围题解java

题解

问题概述

本题要求在一个升序排列的整数数组中，对于每个查询，找出元素 ( k ) 的起始位置和终止位置。如果元素不在数组中，则返回 -1 -1。

输入格式

• 第一行包含两个整数 ( n ) 和 ( q )，分别表示数组的长度和查询的数量。
• 第二行包含 ( n ) 个整数，表示数组的元素。
• 接下来的 ( q ) 行，每行包含一个整数 ( k )，表示一个查询。

输出格式

• 对于每个查询，输出两个整数，表示元素 ( k ) 的起始位置和终止位置。如果元素不存在，则输出 -1 -1。

数据范围

• ( 1 <= n <= 100000 )
• ( 1 <= q <= 10000 )
• ( 1 <= k <= 10000 )

算法分析

由于数组已经按照升序排列，我们可以利用二分查找算法来快速定位元素 ( k ) 的起始和终止位置。

1. 起始位置（SL）：使用二分查找找到第一个大于等于 ( k ) 的位置。如果该位置的元素等于 ( k )，则返回该位置；否则，返回 -1。
2. 终止位置（SR）：使用二分查找找到最后一个小于等于 ( k ) 的位置。如果该位置的元素等于 ( k )，则返回该位置；否则，返回 -1。

代码实现

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

public class Main {

    public static void main(String[] args) throws IOException {
        /*快速读取*/
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] l1 = br.readLine().split(" ");
        String[] l2 = br.readLine().split(" ");
        int n = Integer.parseInt(l1[0]);
        int q = Integer.parseInt(l1[1]);
        int[] arr = new int[n];
        int[] qList = new int[q];
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(l2[i]);
        }
        for (int i = 0; i < q; i++) {
            qList[i] = Integer.parseInt(br.readLine());
        }

        /*核心算法*/
        solution(arr, qList);
        
        /*释放流*/
        br.close();
    }

    private static void solution(int[] arr, int[] qList) {
        for (int k : qList) {
            int l = SL(arr, k);
            int r = SR(arr, k);
            System.out.println(l + " " + r);
        }
    }

    /**
     * 查询左边界
     */
    private static int SL(int[] arr, int k) {
        int l = 0, r = arr.length - 1;
        int mid;
        while (l < r) {
            mid = l + ((r - l) >> 1); //不直接相加除二，是为了避免有些题的和超出范围，当然本题无所谓
            if (arr[mid] >= k) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return arr[l] == k ? l : -1;
    }

    /**
     * 查询右边界
     */
    private static int SR(int[] arr, int k) {
        int l = 0, r = arr.length - 1;
        int mid;
        while (l < r) {
            mid = r - ((r - l) >> 1);//同上，只不过这里反了一个方向
            if (arr[mid] <= k) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        return arr[r] == k ? r : -1;
    }
}

核心

1. SL 方法：

   • 使用二分查找找到第一个大于等于 ( k ) 的位置。
   • 如果找到的位置的元素等于 ( k )，则返回该位置；否则返回 -1。

2. SR 方法：

   • 使用二分查找找到最后一个小于等于 ( k ) 的位置。
   • 如果找到的位置的元素等于 ( k )，则返回该位置；否则返回 -1。

复杂度分析

• 时间复杂度：对于每个查询，二分查找的时间复杂度为 ( O(log n) )，因此总时间复杂度为 ( O(nlog n) )。
• 空间复杂度：除了输入数组外，只使用了常数级别的额外空间，因此空间复杂度为 ( O(1) )。