2024蓝桥杯省赛C++软件算法研究生组题解(含代码)+游记

A题

给你一个音游的游戏记录log.txt，判断玩家的最高连击数

题解

水题，但是要小心，miss的键需要重置k=0，超时但正确的键重置k=1

个人答案是9

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char a[5],b[5];
int main()
{long long x,lasx=0;int mx=0,k=0;freopen("log.txt","r",stdin);while(~scanf("%s%s%lld",a,b,&x)){//printf("%c %c %lld\n",a[0],b[0],x);if(a[0]==b[0]){if(x-lasx>1000)k=1;else{k++;if(mx<k)mx=k;}}elsek=0;lasx=x;}printf("%d",mx);
}

B题

计算1~2024041331404202中有多少个数x满足x! - x*(x+1)/2能被100整除

题解

首先x=10时，x！就会被100整除，所以只需要后面x*(x+1)/2能被100整除即可

可以数论分类讨论，x*(x+1)的因子需要包含3个2和2个5，然后通过x和x+1的奇偶性来删除一些讨论的情况

但是我选择打表，发现x每1000构成一个循环，1~1000只有20个x满足条件

然后再暴力判断一下1~10是否有满足原条件的，发现只有1、3满足

所以最后答案就是1+1+2024041331404 * 20 + 4（24、175、199、200<=202）

40480826628086

（之前写的内容错了，发现自己考场上少算了一个3。。。）

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{long long i,j,tot=0;long long ans=0;for(i=1;i<=1000;i++){if((i*(i+1)/2)%100==0){printf("%lld\n",i);tot++;}}printf("%lld\n",tot);long long jc=1;for(i=1;i<=10;i++){jc*=i;if((jc-i*(i+1)/2)%100==0){printf("%lld\n",i);ans++;}}ans+=2024041331404202ll/1000*tot+4;printf("%lld\n",ans);
}

C题

一个长度为n的数组a[i]

给出数字的封闭图形数的定义

12357没有封闭图形，0469有一个封闭图形，8有两个封闭图形

要求以封闭图形数为第一关键字，数字值为第二关键字给数组排序。

n<=10^5,a[i]<=10^9

题解

结构体排序基础题

每个数字先算出它的封闭图形数作为第一关键字，再把它本身的值作为第二关键字。

结构体排序即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 200005
struct node{int x,sum;bool operator < (const node &t)const{return sum<t.sum||(sum==t.sum&&x<t.x);}
}a[N];
int f[15]={1,0,0,0,1,0,1,0,2,1};
int calsum(int x)
{if(x==0) return 1;int sum=0;while(x){sum+=f[x%10];x/=10;}return sum;
}
int main()
{int n,i;n=gi();for(i=1;i<=n;i++){a[i].x=gi();a[i].sum=calsum(a[i].x);}sort(a+1,a+n+1);printf("%d",a[1].x);for(i=2;i<=n;i++)printf(" %d",a[i].x);
}

D题

给出n个长度为m的环形字符串，设每两个字符串的边权为LCS（最长公共子串）

求连接这n个字符串的最大生成树的代价

n<=200,m<=50

题解

显然瓶颈在建图，后面随便上一个生成树算法都能过。

看题的时候呆住了，想了一下自己SA和SAM都不会，这下咋办

突然发现不需要高级的算法

先O(n^2)枚举所有字符串对

再O（logm）二分答案最长公共子串的长度

最后O(mlogm)哈希检查LCS是否存在

对每个字符串先预处理出各个长度下的哈希值，保存到map里面

总时间复杂度O(n^2*m*(logm)^2)，空间复杂度O(n*m^2)

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
#define N 205
#define M 55
const int mod = 1000000007;
const int base = 31;
char s[N][M*2];
map<int,bool> mp[N][M];
struct node{int u,v,cd;node(){}node(int _u,int _v,int _cd){u=_u;v=_v;cd=_cd;}bool operator < (const node &t)const{return cd>t.cd;}
}e[N*N];
int h[M][M];
int ecnt;
int fa[N];
int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);
}
int main()
{int n,m,i,j,k;scanf("%d%d",&n,&m);for(i=1;i<=n;i++){scanf("%s",s[i]+1);for(j=1;j<=m;j++)s[i][j+m]=s[i][j];for(j=1;j<=m;j++){int hh=0;for(k=j;k<j+m;k++){hh=(1ll*hh*base+s[i][k]-96)%mod;h[k-j+1][j]=hh;mp[i][k-j+1][hh]=1;}}for(j=1;j<i;j++){int l=1,r=m,ans=0,mid;while(l<=r){mid=(l+r)>>1;bool flg=0;for(k=1;k<=m;k++)if(mp[j][mid][h[mid][k]]==1){flg=1;break;}if(flg){l=mid+1;ans=mid;}elser=mid-1;}e[++ecnt]=node(i,j,ans);}}
//	for(i=1;i<=ecnt;i++){
//		printf("%d %d %d\n",e[i].u,e[i].v,e[i].cd);
//	}sort(e+1,e+ecnt+1);for(i=1;i<=n;i++)fa[i]=i;int ans=0,ncnt=0;for(i=1;i<=ecnt;i++){int p=find(e[i].u);int q=find(e[i].v);if(p!=q){fa[p]=q;ans+=e[i].cd;ncnt++;if(ncnt==n-1)break;}}printf("%d",ans);
}

E题

数轴上有n个点，第i个点在ai，从0开始，走一步将坐标-1 或者 +1，一共可以走m步，问最多可以经过多少个点，重复经过一个点只算做一次。

n<=10^5, ai<=10^6,m<=2*10^6

题解

简单贪心

显然不可能反复横跳找点，这样会浪费步数

所以要么向左走到头，然后向右走用完步数；要么反过来。（路径只会有一个拐点）

发现m实际上很小，甚至可以直接暴力前缀和，直接统计m范围内的点。

直接枚举向左、向右走到的位置（拐点），然后前缀和O(1)查询即可。

时间复杂度O(m)

O（nlogn）做法也差不多，把点正负分类之后，用lower_bound查询回到0后剩余步数可以覆盖多少点即可。

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 100005
#define M 2000001
int sum1[M+5],sum2[M+5];
int main()
{int n,i,m,x;n=gi();m=gi();for(i=1;i<=n;i++){x=gi();if(x>=0) sum1[x]++;else sum2[-x]++;}for(i=1;i<=M;i++)sum1[i]+=sum1[i-1];for(i=1;i<=M;i++)sum2[i]+=sum2[i-1];int ans=0;for(i=0;i<=M;i++){if(i*2>m) break;ans=max(ans,max(sum1[i]+sum2[m-i*2],sum2[i]+sum1[m-i*2]));}printf("%d",ans);
}

F题

一个矩阵，每行有一个权值ri，每列有一个权值ci

一个点（x，y）能走到另一个点（z，y），当且仅当，rx<rz且不存在u使得rx<ru<rz

一个点（x，y）能走到另一个点（x，w），当且仅当，cy<cw且不存在v使得cy<cv<cw

现给出T个询问，每次询问从点(x,y)到点(z,w)的路径条数，答案mod 1e9 +7

n,m,T<=10^5，Ri<=10^8

题解

当时一看就不想做了，看了一下道题发现有50%的白送分，就稍微推了一下式子

首先，行列的顺序在这道题中不重要，所以直接进行一个离散化（排序+去重）

题目要求的答案就直接变成了一个网格图路径计数问题，显然组合数

然后预处理一下组合数，搞定了（虽然期间还把题目读错了一次，以为是从大到小走。。）

但是！！！还没完

这个题坑点就在于，有重复的ri和ci值，在路径中也会贡献方案数

而这一点在出题人精心构造的样例下被完美回避了，稍有不慎就是0分和满分的区别

我们按行来看一下，发现如果从（1，1）走到（4，4），实际上就是给答案乘上了当前2的这一行可以选择的方案数，同理列也一样。

但是如果我们从（1，1）走到（3，3），情况就不一样了，由于我们无法在相同ri和ci的地方进行跳跃，只能走严格大于的路，我们就需要提前决策好哪些点是不能走的。

所以此时的答案就不应该乘上当前阶段的行列重复数

最终答案就是

$\binom{z-x}{z-x+y-w}( \prod_{i=x+1}^{z-1} Rcnt[i])( \prod_{i=y+1}^{w-1} Ccnt[i])$

Rcnt[i]表示Ri值第i小的有多少行（也就是重复的ri的数量）

另外还有一些坑点，例如在ri相同时，还需要判断原始的行数是否相同，才能确定是否有答案。列同理。在ri和ci都相同时，就需要判断原始坐标是否一致。

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 100005
#define M 300000
const int mod = 1000000007;
int a[N],b[N],ha[N],hb[N],acnt,bcnt;
int fac[M+5],inv[M+5];
int ksm(int x,int y)
{int ans=1;while(y){if(y&1)ans=1ll*ans*x%mod;y>>=1;x=1ll*x*x%mod;}return ans;
}
void shai()
{int i;fac[0]=inv[0]=1;for(i=1;i<=M;i++)fac[i]=1ll*fac[i-1]*i%mod;inv[M]=ksm(fac[M],mod-2);for(i=M-1;i>=1;i--)inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int C(int n,int m)
{return 1ll*fac[n]*inv[m]%mod*inv[n-m]%mod;
}
int cal(int x,int y,int z,int w)
{return C(z-x+w-y,z-x);
}
int mula[N],mulb[N];
int main()
{int n,m,T,i,x,y,z,w;shai();n=gi();m=gi();T=gi();for(i=1;i<=n;i++)ha[i]=a[i]=gi();for(i=1;i<=m;i++)hb[i]=b[i]=gi();sort(ha+1,ha+n+1);sort(hb+1,hb+m+1);int acnt=unique(ha+1,ha+n+1)-ha-1;int bcnt=unique(hb+1,hb+m+1)-hb-1;for(i=1;i<=n;i++){int pos=lower_bound(ha+1,ha+acnt+1,a[i])-ha;mula[pos]++;}for(i=2;i<=acnt;i++)mula[i]=1ll*mula[i]*mula[i-1]%mod;for(i=1;i<=m;i++){int pos=lower_bound(hb+1,hb+bcnt+1,b[i])-hb;mulb[pos]++;}for(i=2;i<=bcnt;i++)mulb[i]=1ll*mulb[i]*mulb[i-1]%mod;while(T--){x=gi();y=gi();z=gi();w=gi();if(a[x]==a[z]&&b[y]==b[w]){if(x!=z||y!=w) printf("0\n");else printf("1\n");}else{if(a[x]==a[z]){if(x!=z) printf("0\n");else{y=lower_bound(hb+1,hb+bcnt+1,b[y])-hb;w=lower_bound(hb+1,hb+bcnt+1,b[w])-hb;if(y>w) printf("0\n");else printf("%d\n",1ll*mulb[w-1]*ksm(mulb[y],mod-2)%mod);}}else if(b[y]==b[w]){if(y!=w) printf("0\n");else{x=lower_bound(ha+1,ha+acnt+1,a[x])-ha;z=lower_bound(ha+1,ha+acnt+1,a[z])-ha;if(x>z) printf("0\n");else printf("%d\n",1ll*mula[z-1]*ksm(mula[x],mod-2)%mod);}}else{x=lower_bound(ha+1,ha+acnt+1,a[x])-ha;y=lower_bound(hb+1,hb+bcnt+1,b[y])-hb;z=lower_bound(ha+1,ha+acnt+1,a[z])-ha;w=lower_bound(hb+1,hb+bcnt+1,b[w])-hb;
//				printf("%d %d %d %d\n",x,y,z,w);if(x>z||y>w) printf("0\n");else{int ans=cal(x,y,z,w);ans=1ll*ans*mula[z-1]%mod*ksm(mula[x],mod-2)%mod;ans=1ll*ans*mulb[w-1]%mod*ksm(mulb[y],mod-2)%mod;printf("%d\n",ans);}}}}
}
/*
4 4 2
4 2 3 1
2 1 2 1
4 4 1 1
2 2 2 4*/

G题

给出一个n个点的树，每个点有权值ai，求树上不相邻两点的权值异或的最大值。

n<=10^5，ai<=2^31-1

题解

先写了个暴力，就去看最后一题了，最后才来想的正解

发现很简单

直接把所有点插入01Trie树里面

然后枚举1~n的所有点，在Trie树中删除其相邻点，利用贪心遍历01Trie树查询最大异或值

然后再恢复所有相邻点即可

每个点u会被删除d[u]次（u的度数），均摊下来就是边数次，O（n）级别

查询和插入修改都是O（logn）

总复杂度O(nlogn)

不过我比较fw，最后没有调出来，只交了一个暴力。

暴力代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 100005
int a[N],fa[N];
int main()
{int n,i,j;n=gi();for(i=1;i<=n;i++)a[i]=gi();for(i=1;i<=n;i++)fa[i]=gi()+1;int ans=0;for(i=1;i<=n;i++)for(j=i+1;j<=n;j++)if(fa[i]!=j&&fa[j]!=i)ans=max(ans,a[i]^a[j]);printf("%d",ans);
}

正解代码：（比赛结束后才调出来）

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 100005
#define LOG 31
int va[N],fa[N];
int fir[N],to[2*N],nxt[2*N],cnt;
void adde(int a,int b)
{to[++cnt]=b;nxt[cnt]=fir[a];fir[a]=cnt;to[++cnt]=a;nxt[cnt]=fir[b];fir[b]=cnt;
}
struct node{int l,r,siz;
}a[N*LOG];
int T,tcnt;
void insert(int &i,int x,int k,int dep)
{if(!i){i=++tcnt;a[i].siz=0;a[i].l=a[i].r=0;}a[i].siz+=k;if(dep==0) return;if(x&(1<<dep)) insert(a[i].r,x,k,dep-1);else insert(a[i].l,x,k,dep-1);
}
int ans;
void query(int i,int x,int val,int dep)
{//printf("%d( ",val);if(a[i].siz==0) return;if(dep==0){//printf("x val:%d %d\n",x,val);ans=max(ans,x^val);return;}if(x&(1<<dep)){if(a[i].l&&a[a[i].l].siz)query(a[i].l,x,val,dep-1);elsequery(a[i].r,x,val^(1<<dep),dep-1);}else{if(a[i].r&&a[a[i].r].siz)query(a[i].r,x,val^(1<<dep),dep-1);elsequery(a[i].l,x,val,dep-1);}//printf(")");
}
int main()
{int n,i,j;n=gi();for(i=1;i<=n;i++)va[i]=gi();for(i=1;i<=n;i++){fa[i]=gi()+1;if(fa[i])adde(i,fa[i]);}for(i=1;i<=n;i++)insert(T,va[i],1,30);ans=0;for(i=1;i<=n;i++){for(int v,p=fir[i];p;p=nxt[p])insert(T,va[to[p]],-1,30);query(T,va[i],0,30);for(int v,p=fir[i];p;p=nxt[p])insert(T,va[to[p]],1,30);}printf("%d",ans);
}
/*
5
7 4 2 5 4
-1 0 0 2 2
*/

H题

给出一个n个点的树，根为root，每个点有权值ai。

求每个点u的子树中有多少个节点v，满足av<au且av不整除au

你只需要输出每个子树答案的和。

n<=10^5，ai为1~n的一个排列。

题解

当时一看，觉得这题是啥玩意啊

然后看了看性质，发现非常可做

首先，按照子树一个一个算肯定是不可能的，肯定需要一大堆高级数据结构

我们换个思路，既然它求整体的答案，我们可以把枚举子树改为枚举链

因为一个节点v给u做贡献，u必定会在v到root的路径上，而一个点v也只会对v到root路径上的点做贡献。

于是我们就从上到下dfs，维护一个树状数组，里面装当前点u到root的路径上点的权值，

这样就可以直接查询到这条路径上有多少点权大于当前点权

那剩下一个不整除的条件应该怎么办

暴力扫描即可！！！

维护一个桶，来看路径上是否存在点权为x的点

然后对一个点a[u]，暴力枚举a[u]的所有倍数，有一个存在的点，就让答案减一掉即可。（倍数肯定比a[u]大，所以不会多减）

这样做的均摊时间复杂度O（n*ln(n)）

总的时间复杂度也是O（nlogn）（树状数组logn，暴力枚举均摊nlnn）

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{char c;int num=0,flg=1;while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}return num*flg;
}
#define N 100005
int fir[N],to[2*N],nxt[2*N],cnt;
void adde(int a,int b)
{to[++cnt]=b;nxt[cnt]=fir[a];fir[a]=cnt;to[++cnt]=a;nxt[cnt]=fir[b];fir[b]=cnt;
}
int n;
int a[N];
int tong[N];
int tra[N];
int getsum(int x)
{int ret=0;while(x){ret+=tra[x];x-=(x&-x);}return ret;
}
void update(int x,int k)
{while(x<=n){tra[x]+=k;x+=(x&-x);}
}
long long ans;
void dfs(int u,int f)
{ans+=1ll*getsum(n-a[u]+1);for(int i=a[u];i<=n;i+=a[u])if(tong[i]) ans--;tong[a[u]]++;update(n-a[u]+1,1);for(int v,p=fir[u];p;p=nxt[p]){v=to[p];if(v!=f){dfs(v,u);}}update(n-a[u]+1,-1);tong[a[u]]--;
}
int main()
{int rt,i,u,v;n=gi();rt=gi();for(i=1;i<=n;i++)a[i]=gi();for(i=1;i<n;i++){u=gi();v=gi();adde(u,v);}ans=0;dfs(rt,0);printf("%lld",ans);
}