2022.8.10 精弘热身赛

 

全部更新完毕，开摆！

 

紧张刺激的热身赛

（比赛前倒了咖啡都妹有喝）

i和l其实都不该是一点代码都写不出来的程度，复健前路漫长（有没有一种可能，能复健到的上限本来就很低）

希望晚上能把剩下两个搞出来（搞出来力！）

 

 

A：

hello，world！

太紧张了，紧张到连个引号都差点不会打

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
    cout<<'"'<<"Welcome to Jinghong Union."<<'"'<<endl;
    return 0;
}

 

 

B：

太紧张了，紧张到连个strlen都差点不会用

#include<bits/stdc++.h>
#define ll long long
using namespace std;
char s[110];
int main()
{
    scanf("%s",s+1);
    int len=strlen(s+1);
    printf("%c%d%c\n",s[1],len-2,s[len]);
    return 0;
}

 

 

C：

太紧张了，紧张到连个循环都差点不会写

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,a,num;
int main()
{
    scanf("%d",&n);
    a=n;
    while(a){
        num+=a%10;
        a/=10;
    }
    if(n%num==0)printf("Yes\n");
    else printf("No\n");
    return 0;
}

 

 

D：

发现已经有大佬在唰唰ac，不紧张了

循环三个数显然是超时的，所以循环两个判断最后一个

（忘了判断z<=k还wa了几次，丢人）

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int k,s,z;
long long ans;
int main()
{
    scanf("%d%d",&k,&s);
    for(int i=0;i<=min(k,s);i++){
        for(int j=0;j<=min(k,s);j++){
            z=s-j-i;
            if(z>=0&&z<=k)ans++;
        }
    }
    printf("%lld\n",ans);
    return 0;
}

 

 

E：

数据范围很小啊，太好了，直接对每个点暴力枚举八个方向

#include<bits/stdc++.h>
using namespace std;
int h,w;
int hh[10]={0,-1,-1,-1,0,0,1,1,1};
int ll[10]={0,-1,0,1,-1,1,-1,0,1};
char a[55][55];
int work(int x,int y){
    int ans=0;
    for(int i=1;i<=8;i++){
        if(a[x+hh[i]][y+ll[i]]=='#')ans++;
    }
    return ans;
}
int main()
{
    scanf("%d%d",&h,&w);
    for(int i=1;i<=h;i++){
        getchar();
        for(int j=1;j<=w;j++){
            scanf("%c",&a[i][j]);
        }
    }
    for(int i=1;i<=h;i++){
        for(int j=1;j<=w;j++){
            if(a[i][j]=='#')printf("%c",a[i][j]);
            else printf("%d",work(i,j));
        }
        printf("\n");
    }
    return 0;
}

 

 

F：

模拟过程发现是尾放一个头放一个如此循环，所以开两个变量模拟头尾指针，然后按顺序输出

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,head,tail,tag,cnt;
int a[200010],b[200010];
int main()
{
    scanf("%d",&n);
    head=1,tail=cnt=n;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    while(head<=tail){
        if(!tag){
            b[head]=a[cnt];
            head++;
        }
        else{
            b[tail]=a[cnt];    
            tail--;
        }
        tag^=1;
        cnt--;
    }
    for(int i=1;i<=n;i++){
        printf("%d ",b[i]);
    }
    return 0;
}

 

 

G：

暴力递归了，乱算了一下复杂度应该不会超过nlogn

#include<bits/stdc++.h>
#define ll long long
using namespace std;
char s[100010];
int len;
int work(int l,int r,int n){
    if(l==r)return 1;
    int a=n/2;
    for(int i=1;i<=a;i++){
        if(s[l+i-1]!=s[r-i+1])return 0;
    }
    return 1+(work(l,l+a-1,a)&work(r-a+1,r,a));
}
int main()
{
    scanf("%s",s+1);
    len=strlen(s+1);
    printf("%d\n",work(1,len,len));
    return 0;
}

 

 

H：

因为数组越界而wa了11次的题（丢人）

再处理到N我就是……

筛出上限的素数，然后进行一个前缀和

#include<bits/stdc++.h>
using namespace std;
const int N=5000010;
long long l,k,t;
long long dd,vis[N],ee,a[N],cnt,b[N],aa,bb,cc;
void work(long long x){
    for(long long i=2;i<=x;i++){
        if(!vis[i]){
            a[++cnt]=i;
        }
        for(long long j=1;j<=cnt&&i*a[j]<=x;j++){
            vis[i*a[j]]=1;
            if(i%a[j]==0)break;
        }
    }
    for(long long i=2;i<=x;i++){
        b[i]=b[i-1]+(vis[i]?0:1);
    }
}
int main()
{
//    freopen("1.txt","r",stdin);
//    freopen("1.out","w",stdout);
    scanf("%lld",&t);
    work(N-10);
    while(t--){
        scanf("%lld%lld",&l,&k);
        long long ans=b[l+k*2-1]-b[l-1];
        if(ans>k)printf("Yes\n");
        else printf("No\n");
    //    printf("%lld\n",ans);
    }
    return 0;
}

 

简单规律可知……（根本没想到）

从l到l+2k，因为所有偶数除了2都不是质数，所有最多只有k个质数

要满足yes肯定要包括2，特判一下

我怎么没想到呢，我是呆逼

#include<stdio.h>
int t,l,k;
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&l,&k);
        puts(l==2&&k<=3?"Yes":"No");
    }
}

 

 

I：

考场上怎么就没想到呢，明明大致思路都有了

s<=2000，枚举要分成多少个数字

因为每个数字要>2，就对s减去要分成的块数*2，让每个数字变成>0

然后用挡板法/插板法，c[s-i*2-1][i-1]

到底为什么没想出来呢，为什么呢（致可恶的数组越界吃掉的一个小时）

不能提交了所以拿别人的正解对了个拍，大致看了下大佬的过程好像不一样，等下进行一个细读

#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
int s;
long long ans,c[2010][2010];
void work(){
    c[0][0]=c[1][1]=c[1][0]=1;
    for(int i=2;i<=s;i++){
        c[i][0]=1;
        for(int j=1;j<=i;j++){
            c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;
        }
    }
    for(int i=2;i<=s;i++){
        c[1][i]=1;
    }
}
int main()
{
    scanf("%d",&s);
    work();
    for(int i=1;i<=s/3;i++){
        ans=(ans+c[s-i*2-1][i-1])%mod;
    }
    printf("%lld\n",ans);
    return 0;
}

 大致读懂了，dp转移方程a[i]=a[i-1]+a[i-3]，a为i数值时的方案数

3是增加新数字的最低限度，4的话可以由之前的3得到，从i-1转移就是给每种方案的最后一个数字+1，然后要新增一个数字3那就是从i-3转移

 

 

J：

朴素的数学题感和简单规律可知，首先选最大的一个做x肯定比任何一个小于它的好，然后y最好最接近它的二分之一

判断离n/2最近可能在n为奇数时出问题，所以对于奇数再加一个n/2+1

#include<bits/stdc++.h>
using namespace std;
int n,a[100010],ans;
long long maxx=1e18;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    sort(a+1,a+n+1);
    int b=a[n]/2,c=(a[n]%2?a[n]/2+1:a[n]/2);
    for(int i=1;i<=n;i++){
        if(max(b-a[i],a[i]-b)+max(c-a[i],a[i]-c)<maxx){
            maxx=max(b-a[i],a[i]-b)+max(c-a[i],a[i]-c);
            ans=a[i];
        }
    }
    printf("%d %d\n",a[n],ans);
    return 0;
}

 

 

K：

题目等价于：求每个值能对多少区间有贡献（为多少区间的最小值），然后求和

用栈来求每个值作为最小值所在的范围，求它能管辖的左右端点

从左往右挨个入栈，如果当前栈顶的值大于要加入的值，那么就说明栈顶这个值管辖的范围到此为止了，接下来是新数字的time

如果当前栈顶的值小于要加入的值，那么它的管辖范围不被新值影响，继续呆在栈里

加完所有数字以后还在栈里的，它的右端点就是n

左端点同理

然后对于a[i]，它会对(i-l+1)*(r-i+1)个区间有贡献，乘一下然后所有i求和

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n;
int a[N],st[N],top;
long long ans,l[N],r[N];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=n;i++){
        while(top&&a[st[top]]>a[i]){
            r[st[top]]=i-1;
            top--;
        }
        st[++top]=i;
    }
    while(top){
        r[st[top]]=n;
        top--;
    }
    for(int i=n;i>=1;i--){
        while(top&&a[st[top]]>a[i]){
            l[st[top]]=i+1;
            top--;
        }
        st[++top]=i;
    }
    while(top){
        l[st[top]]=1;
        top--;
    }
    for(int i=1;i<=n;i++){
        ans+=(i-l[i]+1)*(r[i]-i+1)*a[i];
    }
    printf("%lld\n",ans);
    return 0;
}

 

 

L：

在大神的指点下领悟了：

异或和相当于二进制不进位加法，所以题目要求异或和等于数值加和，相当于二进制状态下加和不进位，也就是同一有效区间内所有数在同一位二进制上没有重复的1，整个区间内所有数在同一个二进制位上总共只有不多于一个1

那么就维护这个有效区间，从左到右加入数字。如果这个数字加入区间以后满足上述条件，那就更新维护数组。如果不满足，那就从左端点开始移除数字，同时判断现在的左端点是否满足条件，不断更新。

每次的新数字就是新的右端点，持续统计一下每个右端点对应的区间数量，输出总和。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=2e5+10;
int n,ans,l,r;
int a[N],b[N][25],c[25];
int check(int x){
    for(int i=0;i<=20;i++){
        if(b[x][i]&c[i])return 1;
    }
    return 0;
}
int main()
{
    scanf("%d",&n);
    for(int i=1,x;i<=n;i++){
        scanf("%d",&a[i]);
        x=a[i];
        for(int j=0;j<=20;j++){
            b[i][j]=x&1;
            x>>=1;
        }
    }
    l=1;
    for(int i=1;i<=n;i++){
        while(check(i)&&l<=r){
            for(int j=0;j<=20;j++){
                if(b[l][j])c[j]=0;
            }
            l++;
        }
        for(int j=0;j<=20;j++){
            c[j]|=b[i][j];
        }
        r=i;
        ans+=r-l+1;
    }
    printf("%d\n",ans);
    return 0;
}

 

 

 

 

 

 

 

搜索

复制