题目描述

分析：

这道题用到的是二分法，对于二分的本质——边界问题，一直没有理解透彻。在《算法笔记》中看到有关二分的论述让我很有收获，在这里做一下总结。顺便改写了一下y总的模板。

我们先看一下另外一道类似的题目：求出序列中第一个大于等于$x$的元素的位置L以及第一个大于$x$的元素的位置$R$，这样元素$x$在序列中的存在区间就是左闭右开$[L,R)$。

假如对下标从 $0$ 开始，有 $5$ 个元素的序列 {$1, 3, 3, 3, 6$}来说，如果要查询 $3$，则应当得到 $L = 1、R = 4$；如果查询 $5$，则应当得到 $L = R = 4$；如果查询 $6$，则应当得到$L = 4、R = 5$；而如果查询 $8$，则应当得到 $L = R = 5$。显然，如果序列中没有 $x$，那么 $L$ 和 $R$ 也可以理解为假设序列中存在 $x$，则 $x$ 应当存在的位置。

先来考虑第一小问：求序列中第一个大于等于 $x$ 的元素的位置。
假设当前二分区间为 $[l,r]$，那么根据 $mid$ 位置处的元素与欲查元素 $x$ 的大小判断应当往哪个子区间继续查找：

①如果 $A[mid] >= x$，则说明第一个大于等于 $x$ 的元素的位置，一定在 $mid$ 处或 $mid$ 的左侧，应往左子区间 $[l,mid]$ 继续查询，即令 $r = mid$ 。

②如果$A[mid] < x$，说明第一个大于等于$x$的元素的位置一定在 $mid$ 的的右侧，应往右子区间 $[mid+1,r]$ 继续查询，即令 $l = mid + 1$。

相应代码为：

// A[]为递增序列，x为欲查询的数，函数返回第一个大于等于x的位置
// 二分上下界为左闭右闭的[l,r]，传入的初值为[0,n]

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

上述代码有几个需要注意的地方：
1. 循环条件为 $l < r$ 而非 $l ≤ r$ (课本上的二分)，这是由问题本身决定的，“课本上”的二分问题中，查找序列元素不存在时需要返回$-1$，这样当 $l > r$ 时 $[l,r]$ 就不再是闭区间，可以该情况为判定元素不存在的标准，因此 $l ≤ r$ 满足时循环一直进行。但是如果要返回第一个大于等于 $x$ 的元素的位置，就不需要判断该元素本身是否存在，因为就算它不存在，返回的也是“假设它存在，它应该在的位置”，于是当 $l = r$ 时，$[l,r]$ 刚好能夹出唯一的位置，就是需要的结果，因此只要当 $l < r$ 时让循环一直执行即可。
2. 由于当 $l = r$ 时 $while$ 循环停止，因此最后的返回值既可以是 $l$，也可以是 $r$。
3. 二分的所有区间应当能覆盖到所有可能返回的结果。首先，二分下界是$0$是显然的，但是二分上届是 $n$ 还是 $n-1?$ 考虑到欲查询元素有可能比序列中所有的元素都要大，此时应当返回 $n$ (即假设它存在，它应该在的位置)，因此二分上界是 $n$，故二分的初始区间为 $[l,r] = [0,n]$。

接下来解决第二小问：求序列中第一个大于 $x$ 的元素的位置。
做法是类似的。假设当前区间为 $[l,r]$，那么可以根据 $mid$ 位置的元素与欲查元素 $x$ 的大小来判断应往哪个子区间继续查找：

①如果 $A[mid] > x$ ，则说明第一个大于 $x$ 的元素的位置，一定在 $mid$ 处或 $mid$ 的左侧，应往左子区间 $[l,r]$ 继续查询，即令 $r = mid$ 。

②如果 $A[mid] ≤ x$ ，说明第一个大于 $x$ 的元素的位置一定在 $mid$ 的的右侧，应往右子区间 $[mid+1,r]$ 继续查询，即令 $l = mid + 1$ 。

相应代码为：

// A[]为递增序列，x为欲查询的数，函数返回第一个大于x的位置
// 二分上下界为左闭右闭的[l,r]，传入的初值为[0,n]

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

通过思考会发现，lower_bound和upper_bound都在解决这样一个问题：寻找有序序列中第一个满足某条件的元素的位置。这是一个非常重要且经典的问题，平时能遇到的大部分二分法问题都可以归结为这个问题。所谓的“某条件”在序列中一定是从左到右先不满足，然后满足的(否则把该条件取反即可)。

对lower_bound来说，它寻找的就是第一个满足条件“值大于等于 $x$ ”的元素的位置；对upper_bound函数来说，它寻找的是第一个满足“值大于 $x$ ”的元素的位置。

另外，如果要寻找最后一个满足“条件C”的元素的位置，则可以先求第一个满足“条件!C”的元素的位置，然后将该位置减1即可。

分析完毕，在这道题里我们需要用到lower_bound和upper_bound减1。

代码(C++)

#include <iostream>

using namespace std;

const int N = 100010;
int a[N];

int main()
{
    int n, q;
    cin >> n >> q;

    for (int i = 0; i < n; i ++) cin >> a[i];

    while (q --)
    {
        int k;
        cin >> k;

        // 确定二分区间，这里 r 为 n
        int l = 0, r = n;
        while (l < r)
        {
            int mid = l + r >> 1;
            // a[mid] 大于等于 k 说明第一个大于等于 k 的元素一定在 mid 处或 mid 左边
            // 右边界变小，更加关注左半区间
            if (a[mid] >= k) r = mid;

            //a[mid] 小于 k 说明第一个大于等于 k 的元素一定在 mid 右边(不包含 mid)
            // 左边界变大，更加关注右半区间
            else l = mid + 1;
        }

        // 二分一定有答案，但要检查答案是否正确
        // 若序列中没有等于 k 的元素，查找出的是第一个大于 k 的元素的下标
        if (a[l] != k) cout << "-1 -1" << endl;
        else
        {
            cout << l << ' ';
            int l = 0, r = n;
            while (l < r)
            {
                int mid = l + r >> 1;
                // 不同点在这里的 check 函数
                // 这一部分要寻找的是元素 k 的终止位置
                // 我们可以理解为求第一个满足大于 k 的位置，再将结果减 1 ，即是最后一个大于等于 k 的位置
                if (a[mid] > k) r = mid;
                else l = mid + 1;
            }
            // 这也是我们的 r 要开到 n 的原因，假设我们的目标 k 是 a[n-1]
            // 那么第一个大于 k 的下标将达到 n ，如果二分区间到不了这，将导致答案错误
            cout << l - 1 << endl;
        }
    }
}