Codeforces Round #703 (Div. 2)A,B,C1,C2,D

最新推荐文章于 2021-08-13 00:36:31 发布

tcy今天长胖了吗

最新推荐文章于 2021-08-13 00:36:31 发布

阅读量340

点赞数

分类专栏： codeforces 文章标签：二分法思维

本文链接：https://blog.csdn.net/qq_49451105/article/details/113860846

版权

codeforces 专栏收录该内容

47 篇文章 0 订阅

订阅专栏

本文通过分析Codeforces Round #703 (Div.2)中的几道题目，探讨了编程竞赛中的策略和解题思路。从A-Shifting Stacks到D-MaxMedian，作者分享了如何在有限的询问次数内找到最优解，以及如何处理细节问题以避免失分。文章强调了在比赛中计算复杂度、重视细节和保持冷静的重要性，并表达了对未来的决心和信心。

摘要由CSDN通过智能技术生成

Codeforces Round #703 (Div. 2)

A - Shifting Stacks

题意

给定 $n$ 堆箱子，第 $i$ 堆箱子的高度为 $a_i$ ，也就是其中有多少个箱子。你可以把第 $i$ 堆箱子的箱子移动任意数量的箱子到第 $i + 1$ 堆里。问能否经过一翻操作，使得箱子高度严格递增？

思路

要使其严格递增，那必须至少满足 $a_i + 1 = a_{i + 1}$ ；由于前面堆的箱子可以移动任意数量到后面，那最优情况肯定是把第一堆掏空，这样才最有可能使其严格递增；又因为 $a_i + 1 = a_{i + 1}$ ，那么说明到第 $k$ 堆时，至少要满足 $\sum_{i = 1}^{k} a_i \geq (i - 1) \times i / 2$ ，其中左边为当前前缀和，右边为 $a_1 = 0, a_i + 1 = a_{i + 1}$ 情况下到 $k$ 的前缀和，即至少需要满足的情况。

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 2e6 + 9;
const ll MOD = 1e9 + 7;

ll a[N];

int main()
{
    int T ;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        cin >> n;
        ll num = 0;
        bool flag = 0;
        for(ll i = 0; i < n; i++)
        {
            cin >> a[i];
            num += a[i];
            if(num < i * (i + 1) / 2)
                flag = 1;
        }
        if(flag)
        {
            printf("NO\n");
        }
        else
        {
            printf("YES\n");
        }
    }
    return 0;
}

B - Eastern Exhibition

题意

二维平面上有 $n$ 个住户，第 $i$ 个住户住在 $x_i, y_i)$ ，可能出现多个人住在同一个点的情况。现在要你找一个地方办活动，使得所有人到这里的曼哈顿距离最小，问这样的点有几个？

思路

多个人同一个点的信息是误导，我看到被hack的同学把多个点合并了。这充分说明pretest的数据有多弱（

设最终选址为 $(X, Y)$ ，则曼哈顿距离和 $r e s$ 为：
$\sum_{i = 0}^n|x_i - X| + \sum_{i = 0}^n|y_i - Y|$
$x_i$ 和 $y_i$ 对距离的影响是不可抵消的，这个可以举例证明，这里就略过了。最优情况是把 $X$ 和 $Y$ 对距离的影响完全抵消，也就是一半打开绝对值要加负号，一半不用，也就是中点。奇数的终点唯一，偶数则是在最中间的两个 $x_i$ 、 $y_i$ 中间的点都可以取到。

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 2e6 + 9;
const ll MOD = 1e9 + 7;

vector<int> x;
vector<int> y;

int main()
{
    int T ;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        scanf("%d", &n);
        x.clear();
        y.clear();
        for(int i = 0; i < n; i++)
        {
            int X, Y;
            scanf("%d%d", &X, &Y);
            x.push_back(X);
            y.push_back(Y);
        }
        if(n % 2)
        {
            printf(" 1\n");
            continue;
        }
        sort(x.begin(), x.end());
        sort(y.begin(), y.end());
        printf(" %lld\n", (ll)(x[n / 2] - x[n / 2 - 1] + 1) * (ll)(y[n / 2] - y[n / 2 - 1] + 1));//加一个空格是方便自己debug233
    }
    return 0;
}

C1 - Guessing the Greatest (easy version)

题意

数组 $a$ 中有 $n$ 个不重复的数字，每次你可以询问 $[l, r]$ 区间内第二小的数字，要求你在 $40$ 次询问内找到最大的数字。

思路

怎么硕呢，C1一开始的代码虽然算法一般，但是确实能实现 $40$ 次内的要求；但是我后来为了求稳又交了C2的代码，天真的以为cf是只要两次提交有一个过就算过，不知道是后交的覆盖前面的，C2的代码出了细节问题，于是两题一起fst。

这里贴一下C1本来的代码吧，其实思路不是很好，大致思路是：

最大的数字当前范围为 $[l, r]$ （最开始 $l = 1, r = n$ ）；
如果我还不知道这个区间的第二大 $pos_{l, r}$ 在哪里，先询问；
那么现在我们知道了 $pos_{l, r}$ 的值，设 $m i d = (l + r) / 2$ ：
1. 若 $\gt mid$ ，我询问 $[m i d, r]$ 范围内的第二大 $pos_{mid, r}$ 。若 $pos_{mid, r} != pos_{l, r}$ ，说明第二大的数字发生改变，也就意味着第一大数字不在 $[m i d, r]$ 区间；如果一样，说明第一大数字在 $[m i d, r]$ 区间中；
2. 若 $\leq mid$ ，我询问 $[l, m i d]$ 范围内的第二大 $pos_{l, mid}$ 。若 $pos_{l, mid} != pos_{l, r}$ ，说明第二大的数字发生改变，也就意味着第一大数字不在 $[l, m i d]$ 区间；如果一样，说明第一大数字在 $[l, m i d]$ 区间中。

因为最坏情况是每次都要重新询问 $pos_{l, r}$ 的大小，所以范围每缩短一半最坏需要询问2次，复杂度 $O (2 * l o g N)$ ，代入数据范围1e5大概是32次。

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 2e6 + 9;
const ll MOD = 1e9 + 7;

bool vis[N];
int ans = 0;

int ask(int a, int b)
{
    cout << "? " << a << ' ' << b << endl;
    int x;
    cin >> x;
    return x;
}

void func(int l, int r, int tmp)//tmp即[l, r]第二大的值
{
    if(l == r)
    {
        cout << "! " << l << endl;
    }
    else if(r - l == 1)
    {
        if(tmp == 0)
        {
            tmp = ask(l, r);
        }
        if(tmp == l)
            cout << "! " << r << endl;
        else
            cout << "! " << l << endl;
    }
    else
    {
        if(tmp == 0)
        {
            tmp = ask(l, r);
            func(l, r, tmp);
        }
        else
        {
            int nxt;
            int mid = (l + r) / 2;
            if(tmp > mid)
            {
                nxt = ask(mid, r);
                if(nxt != tmp)
                {
                    func(l, mid - 1, 0);
                }
                else
                {
                    func(mid, r, tmp);
                }
            }
            else
            {
                nxt = ask(l, mid);
                if(nxt != tmp)
                {
                    func(mid + 1, r, 0);
                }
                else
                {
                    func(l, mid, tmp);
                }
            }
        }
    }
}

int main()
{
    int n;
    cin >> n;
    int l = 1, r = n;
    bool flag = 0;
    func(1, n, 0);
    return 0;
}

C2 - Guessing the Greatest (hard version)

题意

同C1，唯一区别是只能询问20次。

思路

询问 $[1, n]$ 的第二大 $p o s$ ，之后不再修改其的值，并一直以其为参考。过程如下：

最大的数字当前范围为 $[l, r]$ （最开始 $l = 1, r = n$ ），设 $m i d = (l + r) / 2$ ：
1. 若 $\gt mid$ ，注意此时 $p o s$ 的范围是 $[m i d, n]$ 而不是 $[m i d, r]$ ，那么询问区间 $[m i d, m a x (r, p o s)]$ 的值 $pos_{mid, max(r, pos)}$ ，若 $pos_{mid, max(r, pos)} != pos$ ，说明最大值区间为 $[l, m i d]$ ；如果一样，说明最大值区间为 $[m i d + 1, r]$ ¹；
2. 若 $\leq mid$ ，注意此时 $p o s$ 的范围是 $[1, m i d]$ 而不是 $[l, m i d]$ ，那么询问区间 $[m i n (p o s, l), m i d]$ 的值 $pos_{min(pos, l), mid}$ ，若 $pos_{min(pos, l), mid} != pos$ ，说明最大值区间为 $[m i d + 1, r]$ ；如果一样，说明最大值区间为 $[l, m i d]$ 。

复杂度 $O (l o g N)$ ，代入数据范围1e5大概是16次。

其实C2的思路比C1好多了，简洁很多而且也容易实现，唯一的细节问题是我在实现的时候是把C1代码改成C2的，有个变量名忘记改了。。。所以导致fst

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 2e6 + 9;
const ll MOD = 1e9 + 7;

bool vis[N];
int ans = 0;
int tmp = 0;//[1, n]区间第二大的值

int ask(int a, int b)
{
    cout << "? " << a << ' ' << b << endl;
    int x;
    cin >> x;
    return x;
}

void func(int l, int r)
{
    if(l == r)
    {
        cout << "! " << l << endl;
    }
    else if(r - l == 1)//没错！我就是r - 1 == 1这里！忘记改了直接用的C1的代码！这段直接用C1明显不可以啊{{{(>_<)}}}
    {
        int nxt = ask(l, r);
        if(nxt == l)
            cout << "! " << r << endl;
        else
            cout << "! " << l << endl;
    }
    else
    {
        int nxt;
        int mid = (l + r) / 2;
        if(tmp > mid)
        {
            nxt = ask(mid, max(r, tmp));
            if(nxt != tmp)
            {
                func(l, mid - 1);
            }
            else
            {
                func(mid, r);
            }
        }
        else
        {
            nxt = ask(min(l, tmp), mid);
            if(nxt != tmp)
            {
                func(mid + 1, r);
            }
            else
            {
                func(l, mid);
            }
        }
    }
}

int main()
{
    int n;
    cin >> n;
    tmp = ask(1, n);
    func(1, n);
    return 0;
}

D - Max Median

题意

给一个长度为 $n$ 的数组，定义中位数为一个区间 $[l, r]$ 排序后的第 $(r - l + 1) / 2$ 个数字。现在求所有的长度不小于 $k$ 的子区间中，中位数的最大值是多少。

思路

一道非常有趣的二分，参考思路：Codeforces Round #703 (Div. 2) D. Max Median

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 2e6 + 9;
const ll MOD = 1e9 + 7;

int a[N], sum[N];
int n, k;

bool ok(int x)
{
    for(int i = 0; i < n; i++)
    {
        sum[i + 1] = sum[i] + (a[i + 1] >= x ? 1 : -1);
    }
    int minn = INF;
    int maxx = -INF;
    for(int i = k; i <= n; i++)
    {
        minn = min(minn, sum[i - k]);
        maxx = max(maxx, sum[i] - minn);
        if(maxx > 0)
            return 1;
    }
    return 0;
}

int main()
{
    cin >> n >> k;
    int l = 0, r = 1e9;
    for(int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    while(l + 1 < r)
    {
        int mid = (l + r) >> 1;
        if(ok(mid))
            l = mid;
        else
            r = mid;
    }
    cout << l << endl;
    return 0;
}

总结

先算复杂度，再决定是否要重交代码；
细节，细节，细节。

最难过的一场比赛，但也是非常有意义的一场比赛。我会永远铭记。

之前一直好奇如果多次提交AC代码会怎么样，这次终于明白了，最后一发提交前的代码都会被skip，即使你原来的代码是正确的。不过即使昨天的我了解这个规则，我还是会再交一次C1。求稳没有错，错的是细节。最不应该输在细节。

这场比赛对我意义重大。这是20号前的最后一场，对于还没到1500的我而言是背水一战。比赛前我幻想过超常发挥加100多分，绝地求生，但是心里也明白这是做不到的，更多的是在安慰自己别压力太大，以后还有机会。我没有想到的是，我真的发挥的很好，题目都出的很快，思路完全正确；第一次离前1000名这么近，第一次在比赛结束后，我看到右侧的预估分协助一个绿色的+129。但我更没有想到的是，因为一个小小的变量名，以及因为不清楚cf比赛机制和求稳心态下多交的一次代码，最终会导致这个+号右边的数字减去大半，导致我与目标失之交臂。是不会做吗？不是；是假算法吗？也不是。只是粗心，但是也太不应该了。

无论如何还是要肯定昨天的发挥，确实比以前好很多，或者说在经历了前段时间无休止的练习之后，我的水平可能的确有所提升（吧）。能在1500前接受这样的打击，何尝不是一种成长。 那么光哭是没用的，只能改变计划，接下来的一周继续拼命。

梦想不会止步于1500，所有打不倒我的终将使我变得更强。相信未来的我会感谢现在努力的我，正步履不停。