二分 on 安洛的小窝

[leetcode]搜索旋转排序数组

Fri, 21 Mar 2025 16:12:45 +0800

封面图源：https://www.pixiv.net/artworks/120566071

题目描述

整数数组 nums 按升序排列，数组中的值互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

解题思路

又是一道二分题……但这次我做出来了！

这道题看到时间复杂度 $O(\log n)$ 就知道肯定只能用二分。但是，这道题给出的数组并不是有序的。怎么办呢？注意到题目中给出的数组是一个旋转后的有序数组，那么我们只要知道旋转点 k，就能将数组拆成两个有序数组，在这两个有序数组里面分别搜索即可。那么怎么找到旋转点 k 呢？很显然也只能用二分。注意到旋转点 k 左侧的所有数都 >= nums[0]，右侧的所有数都 < nums[0]，我们可以用 nums[0] 做二分条件，对于二分的l, r, mid，如果 nums[mid]>=nums[0]，说明 mid 偏左，令 l=mid+1；否则说明 mid 偏右，令 r=mid。那么什么时候 mid 刚刚好呢？当 nums[mid]>nums[mid+1] 时，mid 就刚刚好了。找到 mid 之后，分别在 $[first,mid]$ 和 $(mid,last)$ 内进行二分搜索 target 即可。

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.size() == 1) {
            return nums[0] == target ? 0 : -1;
        }
        auto a = nums[0];
        size_t l = 0, r = nums.size() - 1, mid;
        auto flag = false;
        while (l < r) {
            mid = (l + r) / 2;
            if (nums[mid] > nums[mid + 1]) {
                flag = true;
                break;
            } else {
                if (nums[mid] >= a)
                    l = mid + 1;
                else
                    r = mid;
            }
        }
        if (!flag)
        {
            auto result=lower_bound(nums.begin(),nums.end(),target);
            if (result==nums.end()||*result!=target) return -1;
            else return result-nums.begin();
        }else{
            auto midit=nums.begin()+mid+1;
            auto result=lower_bound(nums.begin(),midit,target);
            if (result!=midit&&*result==target) return result-nums.begin();
            else{
                result=lower_bound(midit, nums.end(),target);
                if (result!=nums.end()&&*result==target) return result-nums.begin();
                else return -1;
            }
        }
    }
};

[蓝桥杯2024国A]最长子段题解

Mon, 27 Jan 2025 16:58:57 +0800

封面图源见水印。

题目描述

给定一个长度为 $n$ 的序列 $(s_1,s_2,\cdots,s_n)$ 和三个数 $a,b,c$，你需要找出一对 $L,R$ 满足如下式子：

$$ \sum\limits_{i=L}^Rs_i>a(bR-cL),1 \le L \le R \le n $$

即，序列中的第 $L$ 至 $R$ 项之和大于 $a\cdot (b\cdot R - c \cdot L)$，求出满足条件的 $L,R$ 中 $R - L + 1$ 的最大值。

测试数据保证存在这样的一对 $L$ 和 $R$。

输入格式

输入的第一行包含四个整数 $n,a,b,c$，相邻整数之间使用一个空格分隔。

第二行包含 $n$ 个整数 $s_1,s_2,\cdots,s_n$，相邻整数之间使用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。

样例 #1

样例输入 #1

1
2

4 1 5 6
1 2 3 4

样例输出 #1

提示

对于 $60%$ 的评测用例，$n\le 5000$；
对于所有评测用例，$1\le n\le 3 \times 10^5$，$1\le a,b,c\le 1000$，$|s_i| \le 10^9$。

解题思路

这道题第一眼看到算法标签有二分，马上联想到二分区间长度，然后枚举区间位置来检查答案。于是光速写下如下代码：

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;
using ll = long long;
const int MAXN = 3e5;
int n;
ll a, b, c;
array<ll, MAXN + 5> s;
array<ll, MAXN + 5> sum;

bool check(int mid)
{
    for (auto i = 1; i + mid - 1 <= n; i++)
    {
        ll l = i, r = i + mid - 1;
        if (sum.at(r) - sum.at(l - 1) > a * (b * r - c * l))
            return true;
    }
    return false;
}

int main()
{
    cin >> n >> a >> b >> c;
    for (auto i = 1; i <= n; i++)
    {
        cin >> s.at(i);
        sum.at(i) = s.at(i) + sum.at(i - 1);
    }
    auto l = 1, r = n, ans = 0;
    while (l <= r)
    {
        auto mid = (l + r) / 2;
        if (check(mid))
        {
            ans = mid;
            l = mid + 1;
        }
        else
        {
            r = mid - 1;
        }
    }
    cout << ans;
    return 0;
}

喜提 WA。一开始我还以为是数据范围之类的问题，检查半天，然后猛然发现并非如此。这里要注意二分的一个重要条件，即保证答案是单调的。在上面的代码中，如果一个区间长度被判定为不符合，那么程序就不会搜索比它更长的区间了。但这是不对的。在本题中，一个短区间不符合条件，并不代表长区间也不符合条件。因此，如果希望使用二分搜索，就必须使搜索的目标满足单调条件。那么有没有这样的目标呢？有的有的，这样的目标还有两个，那就是区间的左端点或右端点。但当然不能直接搜索，需要先做一些处理。

我们思考题目给出的条件：$\sum\limits_{i=L}^Rs_i>a(bR-cL),1 \le L \le R \le n$。首先很容易想到用前缀和处理左边的 $\sum\limits_{i=L}^Rs_i$。于是等式左边可以分解为 $sum[r]-sum[l-1]$。这个式子可以移项，将带有 $r$ 的部分和带有 $l$ 的部分分置不等式两边，即 $sum[r]-abr>sum[l-1]-acl$。这暗示我们可以将两个端点分开处理。我们不妨先假设 $r$ 是固定的，思考 $l$ 的情况。根据不等式，$sum[l-1]-acl$ 越小越好，同时根据题目要求区间长度尽量大，那么在 $r$ 固定的情况下，$l$ 显然也是越小越好。那么我们可以得出结论：对于 $l_1<l_2$, 若 $sum[l_1-1]-acl_1<sum[l_2-1]-acl_2$，那么 $l_2$ 是对答案没有贡献的。我们可以遍历一遍数组，计算出 $f[l]=sum[l-1]-acl$ 序列，然后从序列中删除所有对答案没有贡献的元素，最后就会得到一个单调递减的序列 $f$。那么对于这个单调序列，我们就可以用二分搜索来搜索 $l$ 的值。

在具体实现中，我们可以枚举 $r$，那么在单次枚举中 $r$ 就是固定的。在枚举过程中顺便统计 $f[l]=sum[l]-acl$，对于无效的元素，可以将其设置为其前一个有效元素相同的值，这样搜索时就会自动搜索到第一个有效元素了。

代码

附上 AC 代码：

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;
using ll = long long;
const int MAXN = 3e5;
int n;
ll a, b, c;
array<ll, MAXN + 5> s;
array<ll, MAXN + 5> sum;
array<ll, MAXN + 5> f;

int main()
{
    cin >> n >> a >> b >> c;
    for (auto i = 1; i <= n; i++)
    {
        cin >> s.at(i);
        sum.at(i) = s.at(i) + sum.at(i - 1);
    }
    f.at(0)=1e18;
    auto ans=0;
    for (auto i=1; i<=n; i++)
    {
        f.at(i)=min(f.at(i-1),sum.at(i-1)-a*c*i);
        auto l = 1, r = i;
        while (l <= r)
        {
            auto mid = (l + r) / 2;
            if (sum.at(i)-a*b*i>f.at(mid))
            {
                ans=max(ans,i-mid+1);
                r=mid-1;
            }
            else
            {
                l=mid+1;
            }
        }
    }
    cout << ans;
    return 0;
}

[蓝桥杯2024省A]成绩统计题解

Tue, 21 Jan 2025 15:10:48 +0800

封面图源见水印

题目描述

洛谷P10389

小蓝的班上有 $n$ 个人，一次考试之后小蓝想统计同学们的成绩，第 $i$ 名同学的成绩为 $a_i$。当小蓝统计完前 $x$ 名同学的成绩后，他可以从 $1 \sim x$ 中选出任意 $k$ 名同学的成绩，计算出这 $k$ 个成绩的方差。小蓝至少要检查多少个人的成绩，才有可能选出 $k$ 名同学，他们的方差小于一个给定的值 $T$？提示：$k$ 个数 $v_1, v_2, \cdots , v_k$ 的方差 $\sigma^2$ 定义为：$\sigma^2=\dfrac {\sum_{i=1}^k(v_i-\bar v)^2} k$，其中 $\bar v$ 表示 $v_i$ 的平均值，$\bar v = \dfrac {\sum_{i=1}^k v_i} k$。

输入格式

输入的第一行包含三个正整数 $n, k, T $，相邻整数之间使用一个空格分隔。

第二行包含 $n$ 个正整数 $a_1, a2, \cdots, a_n$ ，相邻整数之间使用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。如果不能满足条件，输出 $-1$ 。

样例 #1

样例输入 #1

1
2

5 3 1
3 2 5 2 3

样例输出 #1

提示

检查完前三名同学的成绩后，只能选出 $3, 2, 5 $，方差为 $1.56 $；

检查完前四名同学的成绩后，可以选出 $3, 2, 2 $，方差为 $0.22 < 1 $，所以答案为 $4 $。

对于 $10%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^2$；
对于 $30%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^3$ ；
对于所有评测用例，保证 $1 ≤ n, k ≤ 10^5 $，$1 ≤ T ≤ 2 ^{31} -1 $，$1 ≤ a_i ≤ n $。

解题思路

在蓝桥杯做的第二道二分答案的题，然后我又没做出来 QAQ。

这道题不必过分拘泥于方差如何如何。首先要想到最终答案是要求得一个尽量小的 $x$，$x$ 的二分搜索思路非常简单：二分搜索 $x$，判断是否符合要求，如果符合要求就在左区间继续搜索，否则在右区间搜索。

在确定了这个二分搜索的大方向之后，再考虑如何高效实现判断。要求 $x$ 个数中任意 $k$ 个数的方差，乍看起来复杂度很高，会超时。我最开始也是被这个复杂度吓退了，导致没往这个方向想。但实际上这个复杂度是完全可以接受的。首先在 $x$ 尽量小的基础上，要求方差尽量低，这样才可能小于 $T$。因此容易想到对前 $x$ 个数进行排序，排序之后相邻的数的方差就会比较小。排序的时间复杂度是 $O(nlogn)$。然后就需要挪动一个大小为 $k$ 的窗口，求窗口内的方差。挪动窗口本身是一个接近 $O(n)$ 的复杂度，因此求方差的复杂度不能太高。考虑到我们是在一个挪动的窗口内求方差，尝试通过前缀和进行优化。使用完全平方公式展开求方差的式子，得到 $\sigma^2=\frac{\sum_{i=1}^{k}{v_i^2}-2\sum_{i=1}^{k}{v_i}\bar{v}+k\bar{v}^2}{k}$。其中 $\sum_{i=1}^k{v_i^2}$，$\sum_{i=1}^k{v_i}$ 和 $\bar{v}$ 实际上都可以通过前缀和得到，那么求方差的时间复杂度就是 $O(1)$。那么整个判断的时间复杂度就是排序 $O(nlogn)$ + 求前缀和 $O(n)$ + 挪动窗口求方差 $O(n)$，最终大约是 $O(nlogn)$ 的复杂度。而二分搜索本身是 $O(logn)$ 的复杂度，所以整个算法的复杂度就是 $O(nlog^2n)$。完全在题目要求范围内。

代码

以下附上代码。该代码在蓝桥杯官网通过，但在洛谷无法通过，可能是精度问题。

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

using ll = long long;
using ld = long double;

int main()
{
    int n, k;
    ld t;
    cin >> n >> k >> t;
    vector<ll> a;
    for (auto i = 0; i < n; i++)
    {
        ll temp;
        cin >> temp;
        a.push_back(temp);
    }
    auto ans = distance(a.begin(), a.end()) + 1;
    auto l = a.begin(), r = a.end();
    while (l < r && distance(a.begin(), r) > k)
    {
        auto m = l + (r - l) / 2;
        vector<ll> b(a.begin(), m + 1);
        sort(b.begin(), b.end());
        vector<ll> sum, powsum;
        bool flag = false;
        for (auto i : b)
        {
            sum.push_back(sum.empty() ? i : i + *sum.crbegin());
            powsum.push_back(powsum.empty() ? i * i : i * i + *powsum.crbegin());
        }
        for (auto i = 0; i + k - 1 < b.size(); i++)
        {
            auto j = i + k - 1;
            auto sumk = sum[j] - (i > 0 ? sum[i - 1] : 0);
            auto powsumk = powsum[j] - (i > 0 ? powsum[i - 1] : 0);
            auto avg = ld(sumk) / k;
            auto var = (powsumk - 2 * sumk * avg + k * avg * avg) / k;
            if (var < t)
            {
                flag = true;
                break;
            }
        }
        if (flag)
        {
            ans = min(distance(a.begin(), m), ans);
            r = m;
        }
        else
        {
            l = m + 1;
        }
    }
    if (ans == distance(a.begin(), a.end()) + 1)
        cout << -1 << endl;
    else
        cout << ans + 1 << endl;
    return 0;
}