本文详细解析了一场Codeforces竞赛中的A至G题，涵盖从简单括号序列验证到复杂贪心子序列计算的问题解决思路及代码实现，展示了算法设计与优化技巧。
前言
这场在最开始很顺利，A题6min1A，B题14min1A,但是由于C题过题人数太少一度认为这个C题很难，等有人过了才开始写最开始的想法，C题40min1A，过C之后发现F过的很多，去看提，发现和之前某场读错题意之后的题意一模一样，于是很快就写完，F题50min1A。 之后就开始被翻译误导，把no more than 翻译成可以超过，导致半小时看不懂D的题意在说啥，知道题意之后第一时间想到正解，开始写，发现过不了样例，之后看到题目中说最后一分钟可以不算，于是改改wa14,这个时候只改了一处，其实全部的k都需要改，于是到最后也没debug出来。遂结束。
lajiyuan rating+=72rating+=72rating+=72 1970->2042
A.Regular Bracket Sequence
题意
给你n1n_1n1个((，n2n_2n2个()，n3n_3n3个)(，n4n_4n4个)) ，
这些括号的顺序重排后是否能组成合法的括号序列。
做法
首先可以知道()是没用的而且((的个数一定要等于))。
当有)(的时候一定要有((和))。
代码
#include<stdio.h>
int cnt[5];
int main()
{
for(int i=1;i<=4;i++) scanf("%d",&cnt[i]);
if(cnt[1]==cnt[4])
{
if(cnt[1]==0&&cnt[3]==0) puts("1");
else if(cnt[1]==0 ) puts("0");
else puts("1");
}
else puts("0");
return 0;
}
B. Discounts
题意
给你nnn个商品，第iii个商品的花费为aia_iai，有mmm张优惠券，第i张优惠券可以不购买所有物品价值第qiq_iqi高的物品，使用第i张优惠券，问买到所有商品的花费。
做法
按题意模拟即可。
代码
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 3e5+5;
int a[maxn];
int main()
{
int n,m,q;
scanf("%d",&n);
ll sum=0;
for(int i=1;i<=n;i++) scanf("%d",&a[i]),sum+=a[i];
sort(a+1,a+1+n);
scanf("%d",&m);
for(int i=1;i<=m;i++)
{
scanf("%d",&q);
printf("%lld\n",sum-a[n-q+1]);
}
return 0;
}
C.Painting the Fence
题意
给你nnn个线段，选出其中n−2n-2n−2条线段，让他们覆盖的线段最长。
3≤n,q≤50003 \leq n,q \leq 50003≤n,q≤5000
做法
首先算出两个前缀和，第一个前缀和为到i为止被覆盖一次的线段有多少，第二个前缀和为到i为止被覆盖一次的线段有多少。之后暴力美剧要删除哪两条线段，我们首先在所有覆盖点中把这两条线段中被覆盖一次的点删除，之后再把两条线段重合部分被覆盖两次的点删除就是答案。
代码
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 3e5+5;
int a[maxn],cnt[maxn];
int l[maxn],r[maxn];
int sum[2][maxn];
int main()
{
int n,q;
scanf("%d%d",&n,&q);
for(int i=1;i<=q;i++)
{
scanf("%d%d",&l[i],&r[i]);
for(int j=l[i];j<=r[i];j++) cnt[j]++;
}
int ans=0;
int tmp=0;
for(int i=1;i<=n;i++)
{
if(cnt[i]==1) sum[0][i]=sum[0][i-1]+1;
else sum[0][i]=sum[0][i-1];
if(cnt[i]==2) sum[1][i]=sum[1][i-1]+1;
else sum[1][i]=sum[1][i-1];
if(cnt[i]) tmp++;
}
for(int i=1;i<=q;i++)
{
for(int j=i+1;j<=q;j++)
{
int now=tmp-(sum[0][r[i]]-sum[0][l[i]-1])-(sum[0][r[j]]-sum[0][l[j]-1]);
int ll=max(l[i],l[j]);
int rr=min(r[i],r[j]);
if(ll<=rr) now-=sum[1][rr]-sum[1][ll-1];
ans=max(ans,now);
}
}
printf("%d",ans);
return 0;
}
D.Stressful Training
题意
有n台电脑，第i台初始电量为aia_iai，每分钟消耗电量为bib_ibi,现在要购买一个充电器，每分钟可以让一个电脑的电量增加XXX,比赛一共持续k分钟，充电器在一分钟之内只能给一个电脑充电，问能让所有学生成功完成比赛的最小的XXX（比赛中途不能出现电量小于000，如果恰好在最后一分钟电量为负，也算成功完成）。
做法
首先这个我们把这个kkk减111，因为最后一分钟是无效的，我们不需要考虑，之后我们知道这个答案肯定是可以二分的，所以先二分答案，之后对于每个当前选择的功率，去算每个电脑要在哪些时刻必须充电，在这些时刻标记上，如果被标记的次数和超过kkk，表示最后一分钟之前需要充电的电脑数已经超过kkk，直接返回false，如果总次数不超过k，我们就用sum[i]表示到i为止需要充电的电脑数，只要对于每个i都有i>=sum[i]就可以完成比赛。注意如果在最后一分钟充电不需要算入次数内。
代码
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5+5;
ll a[maxn],b[maxn],c[maxn];
int n,k;
int sum[maxn];
bool check(ll mid)
{
memset(sum,0,sizeof(sum));
int tot=k;
for(int i=1;i<=n;i++)
{
ll tmp=a[i];
if(tmp>=1LL*k*b[i]) continue;
while(tmp<1LL*k*b[i])
{
if(tot==0)
{
if(min(tmp/b[i],(ll)k)+1==k+1) break;
else return false;
}
sum[min(tmp/b[i],(ll)k)+1]++;
tmp+=mid;
tot--;
}
}
ll cc=0;
for(int i=1;i<=k;i++)
{
cc=cc+sum[i];
if(cc>i) return false;
}
return true;
}
int main()
{
scanf("%d%d",&n,&k);
k--;
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
for(int i=1;i<=n;i++) scanf("%lld",&b[i]);
ll l=0,r=1000000000000000000,mid;
while(l<=r)
{
mid=(l+r)/2;
if(check(mid)) r=mid-1;
else l=mid+1;
}
if(l==1000000000000000001) puts("-1");
else printf("%lld\n",l);
return 0;
}
E. Knapsack
题意
给你很多个物品，每个物品的重量为1,2,3,4,5,6,7,81,2,3,4,5,6,7,81,2,3,4,5,6,7,8,现在给出每个重量的物品的种数，问最后容量为W的背包最多装下多重的物品。
1≤w≤10181 \leq w \leq 10^{18}1≤w≤1018
1≤cnti≤10161 \leq cnt_i \leq 10^{16}1≤cnti≤1016
做法
由于WWW很大，我们首先可以选出一些肯定会放在最终背包里面的物品。
我们假设把背包分成很多个容量为840840840的背包，我们可以知道的是，每种物品都可以单独装满这个背包，因为840840840是1−81-81−8的最小公倍数，之后我们只要把所有能凑成的840840840的物品丢进最终的答案，最后每种物品剩余的个数肯定是<840<840<840的，因为第一种最多剩839839839个，以此类推，最后这些物品的总重量是小于840×8840\times8840×8的，我们只需要用一个容量为840×8840\times8840×8的背包对剩下的这些物品进行背包就可以了。
代码
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+5;
ll lef[9];
ll pre[maxn];
int dp[9][maxn];
int main()
{
ll W;
scanf("%lld",&W);
ll sum=0;
for(int i=1;i<=8;i++)
{
scanf("%lld",&lef[i]);
sum=sum+lef[i]*i;
}
if(sum<=W)
{
printf("%lld\n",sum);
return 0;
}
for(int i=1;i<=8;i++)
{
pre[i]=min((ll)840/i,lef[i]);
lef[i]-=pre[i];
}
ll ans=0;
ll tmp=max(0LL,W-840);
for(int i=1;i<=8;i++)
{
ll tt=min(lef[i],(ll)(tmp-ans)/i);
ans=ans+tt*i;
}
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(int i=1;i<=8;i++)
{
for(int j=0;j<=840*8;j++)
{
for(int k=0;k<=pre[i]&&j-k*i>=0;k++)
dp[i][j]|=dp[i-1][j-k*i];
}
}
ll res=0;
for(int j=0;j<=W-ans;j++) if(dp[8][j]) res=ans+j;
printf("%lld\n",res);
return 0;
}
F. Clear the String
题意
给你一个长度为nnn的字符串，每次可以把一个全是同一个字符的子串删除，
求让字符串为空的最小删除次数。
做法
首先这道题删除之后长度变化就不好做了，我们把删除改成变换，可以把一段连续的字符换成另一个字符，这样是不影响答案的，因为这等价于删除，这样我们就可以dpdpdp了。
设dp[i][j]dp[i][j]dp[i][j]为将str[i,j]变成同一个字符的最小操作次数，
所以dp[i][j]=min(dp[i][k],dp[k+1][j])dp[i][j]=min(dp[i][k],dp[k+1][j])dp[i][j]=min(dp[i][k],dp[k+1][j])—(l≤k≤r−1)(l \leq k \leq r-1)(l≤k≤r−1)
特殊的当str[i]=str[j]str[i]=str[j]str[i]=str[j]的时候，答案可以从min(dp[i][j−1],dp[i+1][j])min(dp[i][j-1],dp[i+1][j])min(dp[i][j−1],dp[i+1][j])转移过来。
代码
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 505;
int dp[maxn][maxn];
char str[maxn];
int main()
{
int n;
scanf("%d",&n);
scanf("%s",str+1);
memset(dp,INF,sizeof(dp));
for(int i=1;i<=n;i++) dp[i][i]=1;
for(int i=2;i<=n;i++)
{
for(int j=1;j<=n-i+1;j++)
{
int l=j,r=j+i-1;
if(str[l]==str[r]) dp[l][r]=min(dp[l][r-1],dp[l+1][r]);
for(int k=l;k<=r;k++) dp[l][r]=min(dp[l][r],dp[l][k]+dp[k+1][r]);
}
}
printf("%d\n",dp[1][n]);
return 0;
}
G. Greedy Subsequences
题意
给你一个长度为n的数组，对其中每个长度为k的连续子序列求这个子序列的最长贪心子序列
选定一个数作为第一个数，那么他右面离他最近而且比他大的数作为第二个数，以此类推直到不能再加数这样产生的序列被称为贪心子序列。
对于一个序列选定每一个数作为起点，得到的最长的贪心子序列就是一个序列的最长贪心子序列。
1≤n,k≤1061 \leq n,k \leq 10^61≤n,k≤106
做法
首先这道题一定是滑动窗口来做的。也就是算出第一段的贡献之后，加上一个数的贡献，减去一个数的贡献。
可是我们怎么维护好一些呢，由于要计算每个数靠右的第一个比他大的数，我们这个过程用一个单调栈就能做完。
之后我们把每个数和右边第一个比他大的数建边，我们就可以得到一个森林，再把所有的根同时指向一个虚根，就得到一颗虚树。
我们设树上每个点的权值代表他到虚根这条路径上有多少个点，那么所有点中最大的权值就是答案，那么我们怎么维护加入一个点呢，我们发现，加入一个点的贡献就是把包括他在内的子树中所有点的权值+1，这个用一个基于dfs序的线段树就可以维护，删除一个点的贡献同理，只要将他的子树内所有点的权值-1即可。
代码
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<stack>
#include<vector>
using namespace std;
#define pb push_back
const int maxn = 1e6+5;
struct T
{
int l,r,mid;
int maxx,add;
}tree[maxn<<2];
int in[maxn],ou[maxn];
int a[maxn];
int fa[maxn];
vector<int> G[maxn];
int tim;
void dfs(int rt,int fa)
{
in[rt]=++tim;
for(int i=0;i<G[rt].size();i++)
{
int to=G[rt][i];
if(to==fa) continue;
dfs(to,rt);
}
ou[rt]=tim;
}
void push_up(int rt)
{
tree[rt].maxx=max(tree[rt<<1].maxx,tree[rt<<1|1].maxx);
}
void push_down(int rt)
{
if(tree[rt].add!=0)
{
int tmp=tree[rt].add;
tree[rt<<1].maxx+=tmp;
tree[rt<<1|1].maxx+=tmp;
tree[rt<<1].add+=tmp;
tree[rt<<1|1].add+=tmp;
tree[rt].add=0;
}
}
void build(int rt,int l,int r)
{
tree[rt].l=l;
tree[rt].r=r;
tree[rt].add=0;
if(l==r)
{
tree[rt].maxx=0;
return ;
}
int mid=tree[rt].mid=l+r>>1;
build(rt<<1,l,mid);
build(rt<<1|1,mid+1,r);
push_up(rt);
return ;
}
void update(int rt,int l,int r,int val)
{
if(tree[rt].l>r||tree[rt].r<l) return ;
if(tree[rt].l>=l&&tree[rt].r<=r)
{
tree[rt].add+=val;
tree[rt].maxx+=val;
return ;
}
push_down(rt);
if(tree[rt].mid>=l) update(rt<<1,l,r,val);
if(tree[rt].mid<r) update(rt<<1|1,l,r,val);
push_up(rt);
}
int ans[maxn];
int main()
{
int n,k;
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
build(1,1,n+1);
stack<int>st;
for(int i=n;i>=1;i--)
{
while(!st.empty()&&a[st.top()]<=a[i]) st.pop();
if(st.empty()) G[0].pb(i);
else G[st.top()].pb(i);
st.push(i);
}
dfs(0,-1);
for(int i=n;i>=n-k+1;i--) update(1,in[i],ou[i],1);
ans[n-k+1]=tree[1].maxx;
for(int i=n-k;i>=1;i--)
{
update(1,in[i+k],ou[i+k],-1);
update(1,in[i],ou[i],1);
ans[i]=tree[1].maxx;
}
for(int i=1;i<=n-k+1;i++) printf("%d ",ans[i]);
return 0;
}
扫一扫
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
