The 5th Universal Cup. Stage 1: Grand Prix of Nizhny Novgorod 个人题解。
好难的场qwq喵。
B
题意简述
对于一个序列 \((a_1,a_2,...a_n)\),你的操作是可以选择一对整数 \(1\leq i<j\leq n\),使得 \(a_i=a_j=\frac{a_i+a_j}{2}\)
设 \(f_(a_la_{l+1}....a_r)\) 为对于子序列 \([l,r]\) 第一次选中 \((i,j)\),使得 \(a_i+a_j\) 是奇数的最小操作次数。
对于一个正整数序列,求 \(\sum_{l=1}^n\sum f_(a_la_{l+1}....a_r)^2\) 的贡献
思路简述
对于一段区间 \([l,r]\),若至少存在一个奇数,以及一个偶数,那么这一次操作就可以达成条件。
否则全为奇数,或全为偶数。
设 \(cnt_{0/1/2/3}\),都是一个数字对 \(4\) 取余数的结果。
对于全为奇数的情况,如果同时出现了 \(cnt_1\) 和 \(cnt_3\),则操作一次可以构造出偶数,那么这段区间的贡献值就是 2
对于全为偶数的情况下,如果同时出现了 \(cnt_0\) 和 \(cnt_2\),则操作一次可以构造出奇数,同理这段区间的贡献值就为 2。
手推一下,你发现,本质上,在第 \(j\) 轮能够达成条件,这本质上是 \([0,j-1]\) 的二进制低位都不存在这一二进制位有不同的数字,且第 \(j\) 个二进制位有不同的数字。
于是可以考虑二进制拆分:
对于第 \(j\) 个二进制位,枚举区间,然后检查用前缀和检查一下,这样做是 \(O(n^2)\) 的,不太好。
枚举右端点 \(r\),对于能在这一轮达成贡献的左端点,一定是一个前缀。设当前轮次的二进制状态是 \((b_1b_2...b_n)\)。对于 \(r\) 位置,只需要找到 \(b_r\oplus 1\) 的数的最晚的出现位置 \(pos\),对于 \(l∈[1,pos]\) 都是在这一轮产生贡献的。
等一下,不会把更早时间的答案计重吗?是会的。
所以需要记录一下 \([1,j-1]\) 轮次中的对于第 \(i\) 个位置产生贡献的最后面的位置 \(lst_i\),这一轮新产生的贡献是 \(max(pos-lst_i,0)\)。(代码实现中不知道为啥脑残把数组名开成了 dp)。
那么实际上,这道题也就做完了,时间复杂度为 \(O(n\log A)\)。
fun fuct
- 对 998244353 取模非常的诈骗,实际上,答案不会超过 \(900n^2\)
- 贡献开平方也非常的诈骗,实际上并没有任何用处,开成任意次方都不太影响做法。
细节
似乎对于长度为 \(2\) 的情况要特判。
代码实现
#include<bits/stdc++.h>
using ll=long long;
using namespace std;
const int mod=998244353;
ll mo(ll x){
return (x%mod+mod)%mod;
}
void Silverwolf(){
int n;
cin>>n;
vector<int>a(n+1,0);
for(int i=1;i<=n;i++)cin>>a[i];
ll ans=0;
for(int i=1;i<n;i++){
if(a[i]!=a[i+1]&&a[i]%2!=a[i+1]%2)ans++;
}
vector<int>dp(n+1,0);//上一轮这个位置的贡献
for(int j=1;j<=30;j++){
vector<int>b(n+1,0);
vector<int>pos(2,-1);
vector<int>ndp(n+1,0);
for(int i=1;i<=n;i++){
b[i]=(a[i]&1);
}
for(int i=1;i<=n;i++){
if(i>=3){
if(pos[b[i]^1]!=-1){
ndp[i]=min(i-2,pos[b[i]^1]);
ans=mo(ans+1ll*j*j*max(0,ndp[i]-dp[i]));
}
}
pos[b[i]]=i;
}
for(int i=1;i<=n;i++)a[i]/=2;
for(int i=1;i<=n;i++)dp[i]=max(dp[i],ndp[i]);
}
cout<<ans<<'\n';
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;cin>>T;while(T--)
Silverwolf();
return 0;
}
/*
4
3
2 18 2
10
1 2 3 4 5 6 7 8 9 10
5
20 36 100 36 20
2
1000000000 999999999
1
3
2 18 2
1
10
1 2 3 4 5 6 7 8 9 10
*/
E
思路简述
若第一个鸡蛋不放在第一个位置,我将第一个位置锁住,最终序列必然变成 \(0,1,2....,n-1\),我到对应时刻将鸡蛋锁住。这时的回合数呢,就是 \(\frac{n(n-1)}{2}\)
若第一个鸡蛋被放在了第一个位置,我还将第一个位置锁住,最终序列变成 \(1,2,3,...,n\),对应时刻锁住对应的位置,这时的回合数是 \(\frac{n(n+1)}{2}\)。
总贡献实际上就是 \(\frac{n-1}{n}\frac{n(n-1)}{2}+\frac{1}{n}\frac{n(n+1)}{2}\),没必要直接算出来,直接写就行了。
时间复杂度 \(O(1)\)。
J
题意简述
给定 \(n\) 个小杯子,容量为 \([0,w]\),还有一个大杯子,容量为 \([0,2w]\)。
每个杯子每个位置都有刻度,但小杯子的 \([l_i,n]\) 的刻度是不可见的,大杯子的 \([w,2w]\) 的刻度是不可见的,保证 \(0<l_i<w\)。初始位置,小杯子中有相同高度的水位 \(h\)。
每次操作,你只能倒出保证杯子中有水的部分,问最小的操作次数,能使所有 \([0,w]\) 的水位都能被看出来。
思路简述
似乎与杯子的顺序无关,可以排序。记 \(l_1\leq l_2\leq ..\leq l_n\)。
刚开始,每个杯子可以看到的水位是 \([0,l_i]\),那么相当于 \([0,l_n]\) 的水位已经被解锁了。
如果只有一个杯子,我一定是使用 \(n\) 号杯子,因为每次操作本质是将左区间的右端点拓展 \(l_i\),右区间的左端点也拓展 \(l_i\)。那我显然是使用 \(l_i\) 最高的杯子是最优的。
通过数次操作,我可以倒出其他杯子中的水,这样左区间仍然扩展 \(l_i\),右区间则往下延升了之前解锁的水位的总和。
在使用了若干次 \(n\) 号杯子后,我一定会从 \(n-1,n-2,....,1\) 的顺序使用其他的杯子。
为什么这样?可以用扰动法证明。
任意顺序带来的左端点贡献是不变的。
对于右端点的贡献,是\((x-2)l_{n-1}+(x-3)l_{n-2}+...+l_2\)。由于 \(l_{n-1}\geq l_{n-2}\geq ... \geq l_1\),所以交换顺序显然不优,这个是经典贪心。
能不能找到这样的一个位置,使得 \([1,x]\) 使用 \(n\) 号杯子,接下来的操作使用 \(n,n-1,...n-2\) 杯子。你发现这样的 \(x\) 具有单调性,显然可以二分。
也许答案就处于最早的 \(x\) ?
是不对的。
第 \(x\) 个操作立刻停下。
左端点的贡献是 \(x\times l_n\)。
右端点的贡献是 \((n-1)\times x\times l_n+ (x-2)l_{n-1}+(x-3)l_{n-2}+...+l_2\)
第 \(x+1\) 个操作停下。
左端点的贡献是 \((x+1)\times l_n\)。
右端点的贡献是 \((n-2)\times (x+1)\times l_n+l_{n-1}+(x-2)l_{n-2}+...+l_3\)。
由于要保证操作总次数不变,因此会少使用一次 \(l_1\)。
做个差试试。
\(f(x+1)-f(x)=(n-x-1)\times l_n-\sum_{i=3}^{n-1} l_i\)。
不难发现,但 \(x\) 较小时, \(f(x+1)<f(x)\),但 \(x\)较大时候 \(f(x+1)>f(x)\)。
于是,固定操作次数,总贡献量先增后减。那么操作次数很显然就是先减后增。
由上述过程,我们固定了答案的下界为二分答案得到的 \(x\),那么上界必然不超过 \(x+n\),可以在这一段具有极小值的函数二分极小值点找到答案。
于是,时间复杂度为 \(O(n(\log w+\log n)\)。
实现细节
- 二分时,上下界分别设定 \(L=1,R=\lceil{\frac{w}{2n}}\rceil+1\)
- 开 long long 可能不够,需要开 \(int128\)
#include<bits/stdc++.h>
using ll=long long;
using namespace std;
const int mod=998244353;
const ll inf=1e18;
using i128=__int128;
i128 u=1;
void Silverwolf(){
int n;
ll w;
cin>>n>>w;
vector<ll>a(n+1,0);
for(int i=1;i<=n;i++)cin>>a[i];
sort(a.begin()+1,a.end());
ll ans=inf;
ll l=1,r=w/(2*a[n])+1000000;
auto check=[&](ll mid)->bool{
//用mid 次 n这个杯子
i128 left=u*(mid+1)*a[n];
i128 right=w-u*(mid)*a[n];
if(left>=right){
ans=min(ans,mid);
return true;
}
int cnt=0;
for(int i=n-1;i>=1;i--){
right-=left;
left+=a[i];
++cnt;
if(left>=right){
ans=min(ans,mid+cnt);
return true;
}
}
return false;
};
while(l<r){
ll mid=l+r>>1;
if(check(mid))r=mid;
else l=mid+1;
}
l=l+1;
r=l+n*2+1;
auto f=[&](ll mid)->ll{
i128 left=u*(mid+1)*a[n];
i128 right=w-u*(mid)*a[n];
if(left>=right)return mid;
int cnt=0;
for(int i=n-1;i>=1;i--){
right-=left;
left+=a[i];
++cnt;
if(left>=right){
return mid+cnt;
}
}
return 0;
};
while(r-l>250){
ll mid=(r-l)/3;
ll m1=l+mid;
ll m2=r-mid;
if(f(m2)>f(m1))r=m2;
else l=m1;
}
for(ll i=l;i<=r;i++)ans=min(ans,f(i));
cout<<ans<<'\n';
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// int T;cin>>T;while(T--)
Silverwolf();
return 0;
}
/*
3 34
1 2 4
*/
K
题意简述
有一个长度为 \(n\) 的数组。对于 \(2^n -1\) 个非空子集,是否存在超过一半情况的子集,它的乘积在原数组中出现。
思路简述
对于 \(n>3\) 的情况,实际上只允许以下两种情况。
\(1,1,1...1,x\),也就是前 \((n-1)\) 个都是 \(1\),剩下一个是任意数。
\(1,1,1....,x,x\),也就是前 \((n-2)\) 个都是 \(1\),剩下两个是相等的。
这两种情况出现的次数都是 \(2^{n-1}\),显然严格大于一半。
对于 \(n=2\),需要特判。
浙公网安备 33010602011771号