传送门:牛客
[前题提要]:第一次AK小白月赛,赛后成为我们学校第一个牛客颜色到黄色的(好吧只是他们都不打牛客罢了),但是还是具有纪念意义的,故记录一下
这次的题目A~E个人感觉是偏简单的.
A 小A的文化节:
简单模拟题.
只要累加一下参加的比赛的贡献即可.
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn],b[maxn];
int main() {
int n=read();int m=read();
for(int i=1;i<=n;i++) {
a[i]=read();
}
int sum=0;
for(int i=1;i<=m;i++) {
b[i]=read();
sum+=a[b[i]];
}
cout<<sum<<endl;
return 0;
}
B.小A的游戏
简单的数学题.
初看毫无思路,但是按照经典套路先列几个未知数,考虑设
x
x
x为A获胜的场数,
y
y
y为平局的场数,
z
z
z为B获胜的场数.
那么不难发现,A赢得的分数为
3
∗
x
+
y
3*x+y
3∗x+y,B赢得的分数为
3
∗
z
+
y
3*z+y
3∗z+y,然后就会发现两者差必须得满足3的倍数.但是这个只是必要条件.当然按照直觉,在比赛时,直接交一发试试正确即可,就会发现轻松AC了.现在考虑证明上述条件是充分条件.考虑现在我们有
X
X
X分数和
Y
Y
Y分数,两者差为3的倍数,考虑如何构造?我们发现只要设
x
=
X
−
Y
3
,
z
=
0
,
y
=
Y
x=\frac{X-Y}{3},z=0,y=Y
x=3X−Y,z=0,y=Y即可构造一组合法方案.现在我们就证明了充分性.
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
int T=read();
while(T--) {
int x=read();int y=read();
if(abs(x-y)%3!=0) {
cout<<"No"<<endl;
}
else {
cout<<"Yes"<<endl;
}
}
return 0;
}
C 小A的数字
简单贪心.
对于每一位如果该位是0,那么现在对应的答案该位我们填1.如果该位不是0,我们要填尽量的填0.
为什么说是尽量的呢.因为有一个坑点,假设我们现在的数字每一位都非0,我们按照上述的贪心构造,会发现答案最后是0,但是题目要求我们输出一个正整数,所以特判一下上述情况即可.(赛时我就因为这个wa了一发…)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
int T=read();
while(T--) {
string s;cin>>s;int n=stoi(s);
vector<int>v;
for(int i=s.length()-1;i>=0;i--) {
if(s[i]-'0'>0) {
v.push_back(0);
}
else {
v.push_back(1);
}
}
reverse(v.begin(),v.end());
int flag=0;
for(int i=0;i<v.size();i++) {
if(v[i]==0) {
if(flag==0) {
while(i+1<=v.size()-1&&v[i+1]==0) {
i++;
}
flag=1;
if(i==v.size()-1) {
for(int j=1;j<=9;j++) {
if(j!=s.back()-'0') {
cout<<j;
break;
}
}
}
}
else {
cout<<v[i];
}
}
else {
cout<<v[i];
}
}
cout<<endl;
}
return 0;
}
E 小A的任务
简单贪心.
唯一需要注意的是存在这样一种情况,就是可能我们A多完成几个,然后选后面的B比前面的B更为优秀.
然后顺着上面的思路,发现
q
q
q才100,很好,对于每一个
q
q
q我们都可以进行枚举.考虑枚举我们A任务完成了
i
i
i个(按照题目要求,完成的任务必然是前缀任务),然后对于这A个任务,我们解锁了
i
i
i个B任务,现在我们的问题就是求这
i
i
i个中的前
k
k
k小和.继续抽象一下就会发现我们需要维护的是B任务前缀前
k
k
k小和.考虑使用优先队列来维护这个.一旦当前的队列中的数超过了
k
k
k个,贪心的想,我们必然要将队列中最大的那个数给踢出我们的贡献.这样就做完了.
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn],b[maxn];int sum[maxn];
signed main() {
int n=read();int q=read();
for(int i=1;i<=n;i++) {
a[i]=read();
sum[i]=sum[i-1]+a[i];
}
for(int i=1;i<=n;i++) {
b[i]=read();
}
for(int i=1;i<=q;i++) {
int k=read();
priority_queue<int>Q;int sum2=0;
int ans=ll_INF;
for(int j=1;j<=n;j++) {
Q.push(b[j]);sum2+=b[j];
if(Q.size()>k) {
sum2-=Q.top();
Q.pop();
}
if(Q.size()>=k)
ans=min(ans,sum2+sum[j]);
}
cout<<ans<<endl;
}
return 0;
}
D&F 小A的线段(Easy&Hard version)
E
a
s
y
Easy
Easy版本.
发现线段数才10个,直接枚举选取的线段的子集即可.对于枚举的选择的子集,此时我们需要判断的是该方案是否满足条件.
因为我们需要判断是否每一个点都被覆盖了至少2次,直接将其转化为区间覆盖问题即可.可以用线段树之类的数据结构维护(复杂度为
2
m
m
l
o
g
n
2^mmlogn
2mmlogn,但是这个复杂度需要手写清空函数,不能直接建树覆盖,直接建树是O(n)的).当然对于本题,我们只要使用差分数组即可.复杂度为
2
m
n
2^mn
2mn
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const int mod=998244353;
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Line{
int l,r;
bool operator < (const Line &rhs) const {
if(l!=rhs.l) return l<rhs.l;
else return r<rhs.r;
}
}line[maxn];int sum[maxn];
signed main() {
int n=read();int m=read();
for(int i=1;i<=m;i++) {
line[i].l=read();line[i].r=read();
}
sort(line+1,line+m+1);
int ans=0;
for(int i=0;i<(1<<m);i++) {
for(int j=1;j<=m;j++) {
if(i&(1<<(j-1))) {
sum[line[j].l]++;
sum[line[j].r+1]--;
}
}
int flag=0;
for(int j=1;j<=n;j++) {
sum[j]+=sum[j-1];
if(sum[j]<2) {
flag=1;break;
}
}
if(flag==0) ans++;
for(int j=1;j<=n;j++) {
sum[j]=0;
}
}
cout<<ans%mod<<endl;
return 0;
}
H
a
r
d
Hard
Hard版本.
发现
m
m
m到100了,显然已经不能枚举子集了,其实按照经验来说,一看到这道题,应该想到使用dp来解决本问题.反正我一看到就想到了.
考虑如何
d
p
dp
dp,我们发现最终的状态和每个点覆盖的次数有关,不难想到一种状态是记录最后覆盖两次的点的位置(也就是在这个位置之前的点都被覆盖了两次).诶,此时我们就发现光记录两次似乎很难递推,因为我们需要用到另一种状态,也就是覆盖一次的点的位置.所以我们再把它加上.
在确定我们的dp方程之前,我们先要明确一点,上述的最后覆盖两次的点的位置以及至少覆盖了一次的点的位置一定是给定的线段的右端点位置,这一点很重要,并且覆盖两次的点的位置一定在覆盖一次的点的位置的左边
所以我们考虑设计dp状态,考虑设
d
p
[
i
]
[
j
]
[
k
]
dp[i][j][k]
dp[i][j][k]为枚举到第
i
i
i个线段,此时最后覆盖两次的点的位置是第
j
j
j条线段,最后覆盖一次的点的位置是第
k
k
k条线段的方案数.然后考虑如何进行递推.
-
l i n e [ i ] . l < = l i n e [ j ] . r + 1 , l i n e [ i ] . r < = l i n e [ j ] . r line[i].l<=line[j].r+1,line[i].r<=line[j].r line[i].l<=line[j].r+1,line[i].r<=line[j].r,如下图:
不难发现此时选取 i i i这个线段,并不会改变原本覆盖状态,但是此时的方案数依旧是需要累加的.
d p [ i ] [ j ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]+=dp[i-1][j][k] dp[i][j][k]+=dp[i−1][j][k] -
l i n e [ i ] . l < = l i n e [ j ] . r + 1 line[i].l<=line[j].r+1 line[i].l<=line[j].r+1, l i n e [ i ] . r < = l i n e [ k ] . r line[i].r<=line[k].r line[i].r<=line[k].r
不难发现此时选 i i i这个线段改变了覆盖两次的状态,但是没有改变覆盖一次的状态:
d p [ i ] [ i ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][i][k]+=dp[i-1][j][k] dp[i][i][k]+=dp[i−1][j][k] -
l i n e [ i ] . l < = l i n e [ j ] . r + 1 line[i].l<=line[j].r+1 line[i].l<=line[j].r+1, l i n e [ i ] . r > l i n e [ k ] . r line[i].r>line[k].r line[i].r>line[k].r
d p [ i ] [ k ] [ i ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][k][i]+=dp[i-1][j][k] dp[i][k][i]+=dp[i−1][j][k] -
l i n e [ i ] . l > l i n e [ j ] . r , l i n e [ i ] . r < = l i n e [ k ] . r line[i].l>line[j].r,line[i].r<=line[k].r line[i].l>line[j].r,line[i].r<=line[k].r
d p [ i ] [ j ] [ k ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]+=dp[i-1][j][k] dp[i][j][k]+=dp[i−1][j][k] -
l i n e [ i ] . l > l i n e [ j ] . r , l i n e [ i ] . r > l i n e [ k ] . r line[i].l>line[j].r,line[i].r>line[k].r line[i].l>line[j].r,line[i].r>line[k].r
d p [ i ] [ j ] [ i ] + = d p [ i − 1 ] [ j ] [ k ] dp[i][j][i]+=dp[i-1][j][k] dp[i][j][i]+=dp[i−1][j][k]
需要注意的是上述递推方程必须将所有线段按左端点进行排序才能保证正确性.可以思考一下为什么一定要排序?
因为假设我们不进行排序,可能存在一个线段提前覆盖了后面部分,但是我们上述的dp方程是没有记录这种情况的,所以这种情况会被我们抛弃.而如果排序了,因为左端点单调性,会导致上述情况是不合法的.(所以其实上述的递推方程中的4,5是不合法的,也就是可以不用考虑这种情况)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
ll x=0,w=1;char ch=getchar();
for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*w;
}
inline void print(__int128 x){
if(x<0) {putchar('-');x=-x;}
if(x>9) print(x/10);
putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const int mod=998244353;
const double eps=1e-8;
#define int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Line{
int l,r;
bool operator < (const Line &rhs) const {
if(l!=rhs.l) return l<rhs.l;
else return r<rhs.r;
}
}line[maxn];
int dp[210][210][210];
signed main() {
int n=read();int m=read();
for(int i=1;i<=m;i++) {
line[i].l=read();line[i].r=read();
}
sort(line+1,line+m+1);
dp[0][0][0]=1;
for(int i=1;i<=m;i++) {
for(int j=0;j<=i-1;j++) {//覆盖2次
for(int k=0;k<=i-1;k++) {//覆盖1次
dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
if(line[i].l<=line[j].r+1) {
if(line[i].r<=line[j].r) {
dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
}
else {
if(line[i].r<=line[k].r) {
dp[i][i][k]+=dp[i-1][j][k];dp[i][i][k]%=mod;
}
else {
dp[i][k][i]+=dp[i-1][j][k];dp[i][k][i]%=mod;
}
}
}
// else {这一部分可以不用,因为本身就是不合法的
// if(line[i].r<=line[k].r+1) {
// dp[i][j][k]+=dp[i-1][j][k];dp[i][j][k]%=mod;
// }
// else {
// dp[i][j][i]+=dp[i-1][j][k];dp[i][j][i]%=mod;
// }
// }
}
}
}
int ans=0;
for(int j=0;j<=m;j++) {
for(int k=0;k<=m;k++) {
if(line[j].r>=n) {
ans+=dp[m][j][k];ans%=mod;
}
}
}
cout<<ans<<endl;
return 0;
}