Codeforces Round #703 (Div. 2)
A - Shifting Stacks
题意
给定 n n n 堆箱子,第 i i i 堆箱子的高度为 a i a_i ai ,也就是其中有多少个箱子。你可以把第 i i i 堆箱子的箱子移动任意数量的箱子到第 i + 1 i + 1 i+1 堆里。问能否经过一翻操作,使得箱子高度严格递增?
思路
要使其严格递增,那必须至少满足 a i + 1 = a i + 1 a_i + 1 = a_{i + 1} ai+1=ai+1 ;由于前面堆的箱子可以移动任意数量到后面,那最优情况肯定是把第一堆掏空,这样才最有可能使其严格递增;又因为 a i + 1 = a i + 1 a_i + 1 = a_{i + 1} ai+1=ai+1 ,那么说明到第 k k k 堆时,至少要满足 ∑ i = 1 k a i ≥ ( i − 1 ) × i / 2 \sum_{i = 1}^{k} a_i \geq (i - 1) \times i / 2 ∑i=1kai≥(i−1)×i/2 ,其中左边为当前前缀和,右边为 a 1 = 0 , a i + 1 = a i + 1 a_1 = 0, a_i + 1 = a_{i + 1} a1=0,ai+1=ai+1 情况下到 k k 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 n n 个住户,第 i i i 个住户住在 ( x i , y i ) (x_i, y_i) (xi,yi) ,可能出现多个人住在同一个点的情况。现在要你找一个地方办活动,使得所有人到这里的曼哈顿距离最小,问这样的点有几个?
思路
多个人同一个点的信息是误导,我看到被hack的同学把多个点合并了。这充分说明pretest的数据有多弱(
设最终选址为
(
X
,
Y
)
(X, Y)
(X,Y) ,则曼哈顿距离和
r
e
s
res
res 为:
r
e
s
=
∑
i
=
0
n
∣
x
i
−
X
∣
+
∑
i
=
0
n
∣
y
i
−
Y
∣
res = \sum_{i = 0}^n|x_i - X| + \sum_{i = 0}^n|y_i - Y|
res=i=0∑n∣xi−X∣+i=0∑n∣yi−Y∣
x
i
x_i
xi 和
y
i
y_i
yi 对距离的影响是不可抵消的,这个可以举例证明,这里就略过了。最优情况是把
X
X
X 和
Y
Y
Y 对距离的影响完全抵消,也就是一半打开绝对值要加负号,一半不用,也就是中点。奇数的终点唯一,偶数则是在最中间的两个
x
i
x_i
xi 、
y
i
y_i
yi 中间的点都可以取到。
代码
#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 a a 中有 n n n 个不重复的数字,每次你可以询问 [ l , r ] [l, r] [l,r] 区间内第二小的数字,要求你在 40 40 40 次询问内找到最大的数字。
思路
怎么硕呢,C1一开始的代码虽然算法一般,但是确实能实现 40 40 40 次内的要求;但是我后来为了求稳又交了C2的代码,天真的以为cf是只要两次提交有一个过就算过,不知道是后交的覆盖前面的,C2的代码出了细节问题,于是两题一起fst。
这里贴一下C1本来的代码吧,其实思路不是很好,大致思路是:
-
最大的数字当前范围为 [ l , r ] [l, r] [l,r] (最开始 l = 1 , r = n l = 1, r = n l=1,r=n );
-
如果我还不知道这个区间的第二大 p o s l , r pos_{l, r} posl,r 在哪里,先询问;
-
那么现在我们知道了 p o s l , r pos_{l, r} posl,r 的值,设 m i d = ( l + r ) / 2 mid = (l + r) / 2 mid=(l+r)/2 :
- 若 p o s 1 > m i d pos1 \gt mid pos1>mid ,我询问 [ m i d , r ] [mid, r] [mid,r] 范围内的第二大 p o s m i d , r pos_{mid, r} posmid,r 。若 p o s m i d , r ! = p o s l , r pos_{mid, r} != pos_{l, r} posmid,r!=posl,r ,说明第二大的数字发生改变,也就意味着第一大数字不在 [ m i d , r ] [mid, r] [mid,r] 区间;如果一样,说明第一大数字在 [ m i d , r ] [mid, r] [mid,r] 区间中;
- 若 p o s 1 ≤ m i d pos1 \leq mid pos1≤mid ,我询问 [ l , m i d ] [l, mid] [l,mid] 范围内的第二大 p o s l , m i d pos_{l, mid} posl,mid 。若 p o s l , m i d ! = p o s l , r pos_{l, mid} != pos_{l, r} posl,mid!=posl,r ,说明第二大的数字发生改变,也就意味着第一大数字不在 [ l , m i d ] [l, mid] [l,mid] 区间;如果一样,说明第一大数字在 [ l , m i d ] [l, mid] [l,mid] 区间中。
因为最坏情况是每次都要重新询问 p o s l , r pos_{l, r} posl,r 的大小,所以范围每缩短一半最坏需要询问2次,复杂度 O ( 2 ∗ l o g N ) O(2 * logN) O(2∗logN),代入数据范围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 ] [1, n] [1,n] 的第二大 p o s pos pos ,之后不再修改其的值,并一直以其为参考。过程如下:
- 最大的数字当前范围为
[
l
,
r
]
[l, r]
[l,r] (最开始
l
=
1
,
r
=
n
l = 1, r = n
l=1,r=n ),设
m
i
d
=
(
l
+
r
)
/
2
mid = (l + r) / 2
mid=(l+r)/2 :
- 若 p o s > m i d pos \gt mid pos>mid,注意此时 p o s pos pos 的范围是 [ m i d , n ] [mid, n] [mid,n] 而不是 [ m i d , r ] [mid, r] [mid,r],那么询问区间 [ m i d , m a x ( r , p o s ) ] [mid, max(r, pos)] [mid,max(r,pos)] 的值 p o s m i d , m a x ( r , p o s ) pos_{mid, max(r, pos)} posmid,max(r,pos) ,若 p o s m i d , m a x ( r , p o s ) ! = p o s pos_{mid, max(r, pos)} != pos posmid,max(r,pos)!=pos ,说明最大值区间为 [ l , m i d ] [l, mid] [l,mid];如果一样,说明最大值区间为 [ m i d + 1 , r ] [mid + 1, r] [mid+1,r] 1;
- 若 p o s ≤ m i d pos \leq mid pos≤mid,注意此时 p o s pos pos 的范围是 [ 1 , m i d ] [1, mid] [1,mid] 而不是 [ l , m i d ] [l, mid] [l,mid],那么询问区间 [ m i n ( p o s , l ) , m i d ] [min(pos, l), mid] [min(pos,l),mid] 的值 p o s m i n ( p o s , l ) , m i d pos_{min(pos, l), mid} posmin(pos,l),mid ,若 p o s m i n ( p o s , l ) , m i d ! = p o s pos_{min(pos, l), mid} != pos posmin(pos,l),mid!=pos ,说明最大值区间为 [ m i d + 1 , r ] [mid + 1, r] [mid+1,r] ;如果一样,说明最大值区间为 [ l , m i d ] [l, mid] [l,mid] 。
复杂度 O ( l o g N ) O(logN) O(logN),代入数据范围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 n n 的数组,定义中位数为一个区间 [ l , r ] [l, r] [l,r] 排序后的第 ( r − l + 1 ) / 2 (r - l + 1)/2 (r−l+1)/2 个数字。现在求所有的长度不小于 k k 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,所有打不倒我的终将使我变得更强。相信未来的我会感谢现在努力的我,正步履不停。
由于 [ r , t m p ] [r, tmp] [r,tmp] 这一部分潜在区间已经被预先排除,所以上限取 r r r 。 ↩︎