隐藏页面特效

2020年第十一届蓝桥杯大赛软件类省赛C/C++大学A组真题

1|0Preface


受不了了上次做21年把三个组别的都做了，题量有那么一点点大的说

这次只做了A组的题，主要感觉蓝桥杯的题大概看一下难度就差不多得了，水题写多也无宜

2|0门牌制作


直接枚举，答案624

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int
using namespace std;
int ans=0;
int main()
{
	for (RI i=1;i<=2020;++i)
	{
		int x=i; while (x) ans+=x%10==2,x/=10;
	}
	return printf("%d",ans),0;
}

3|0既约分数


直接枚举，答案2481215

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int
using namespace std;
int ans=0;
inline int gcd(CI n,CI m)
{
	return m?gcd(m,n%m):n;
}
int main()
{
	for (RI i=1;i<=2020;++i) for (RI j=1;j<=2020;++j)
	if (gcd(i,j)==1) ++ans; return printf("%d",ans),0;
}

4|0蛇形填数


代码都不用写，把原图顺时针旋转45度，然后就变成一个三角形的数字塔

不难发现对于原来图中(n,n)的位置，再旋转后的图里位置为(2n−1,n)，因此我们只要求出在数字塔中第39行最中间的那个元素即可

简单计算得到答案为(38+1)×382+20=761

5|0七段码


枚举每个管的亮灭情况，然后建个图跑一下是不是所有亮管在一个联通块内

注意题目问的是表达的字符的种数，所以都不亮不能算作一种情况，答案为80

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int
using namespace std;
int c[10],g[10][10],fa[10],ans;
inline int getfa(CI x)
{
	return fa[x]!=x?fa[x]=getfa(fa[x]):x;
}
inline void DFS(CI now=1)
{
	if (now>7)
	{
		bool flag=1; RI i,j; for (i=1;i<=7;++i) fa[i]=i;
		for (i=1,j;i<=7;++i) for (j=1;j<=7;++j)
		if (i!=j&&c[i]&&c[j]&&g[i][j]) fa[getfa(i)]=getfa(j);
		for (i=1;i<=7;++i) for (j=1;j<=7;++j)
		if (i!=j&&c[i]&&c[j]) flag&=getfa(i)==getfa(j);
		ans+=flag; return;
	}
	c[now]=1; DFS(now+1); c[now]=0; DFS(now+1);
}
int main()
{
	g[1][2]=g[1][6]=1; g[2][1]=g[2][7]=g[2][3]=1;
	g[3][2]=g[3][4]=g[3][7]=1; g[4][3]=g[4][5]=1;
	g[5][4]=g[5][6]=g[5][7]=1; g[6][1]=g[6][5]=g[6][7]=1;
	g[7][2]=g[7][3]=g[7][5]=g[7][6]=1;
	return DFS(),printf("%d",ans-1),0;
}

6|0平面分割


有点意思的题，算是狠狠复习了一波平面分割的姿势

首先我们考虑先把圆的划分方案确定在添加直线，那么问题就是20个圆最多把平面分成多少块

我们假设n个圆产生的交点数为f(n)，则在加入第n+1个圆时显然最多产生2n个交点（新加入的圆和每个圆都相交），区域数目就会增加2n

然后把式子化一下就是f(n)=n2−n+2，然后我们考虑在这基础上加入直线的情形

如果不考虑圆仅考虑直线的话就是个经典的结论，n条直线把平面分成g(n)=n(n+1)2+1

然后我们再考虑把两部分拼起来，不难发现当每条直线都和每个圆相交时划分出的区域数最大

具体算的话因为有20个圆，所以每次多产生40个交点，20条直线一共多产生800个交点

不过细节上如果直接把800+f(20)+g(20)会有问题，因为此时第一条直线不在默认把平面分成两块了，而是直接在圆划分的区域中产生贡献

因此最后要减去g(1)=2，最后答案是1391

7|0成绩分析


SB题，按题意模拟即可

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
int n,mi=100,mx,avg,x;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	RI i; for (scanf("%d",&n),i=1;i<=n;++i) 
	scanf("%d",&x),mi=min(mi,x),mx=max(mx,x),avg+=x;
	return printf("%d\n%d\n%.2lf",mx,mi,1.0*avg/n),0;
}

8|0回文日期


SB题，按题意模拟即可，注意要处理闰年

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
inline bool judge(CI x)
{
	return x%400==0||(x%4==0&&x%100!=0);
}
int st,y,m,d,ans1,ans2;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&st),y=st/10000,m=st/100%100,d=st%100;;)
	{
		if (++d>day[m-1]+(m==2&&judge(y))) if (++m,d=1,m>12) ++y,m=1;
		int A=m/10,B=m%10,C=d/10,D=d%10;
		if (D*1000+C*100+B*10+A==y)
		{
			if (!ans1) ans1=y*10000+m*100+d;
			if (A==C&&B==D) { ans2=y*10000+m*100+d; break; }
		}
	}
	return printf("%d\n%d",ans1,ans2),0;
}

9|0子串分值


考虑对于每一种字符分别考虑贡献，对于每一个位置i，我们考虑求出si这个字符上次出现的位置prei（默认为0）和下次出现的位置nxti（默认为n+1）

然后i这个位置上的字符产生贡献的区间数目就是(i−prei)(nxti−i)，然后就很简单了

#include<cstdio>
#include<iostream>
#include<cstring>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
char s[N]; int n,lst[26],pre[N]; long long ans;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	RI i; for (scanf("%s",s+1),n=strlen(s+1),i=1;i<=n;++i)
	pre[i]=lst[s[i]-'a'],lst[s[i]-'a']=i;
	for (i=0;i<26;++i) lst[i]=n+1;
	for (i=n;i;--i) ans+=1LL*(i-pre[i])*(lst[s[i]-'a']-i),lst[s[i]-'a']=i;
	return printf("%lld",ans),0;
}

10|0字串排序


还是很有意思的一道题，感觉这种思路的题目好像之前在CF见过类似的

首先我们考虑解决长度为n的串的最大逆序对个数这一问题，如果n≤26时答案显然就是一个n(n−1)2

但是当n>26时就会出现有字符重复的情况，我们稍作分析发现此时只要把每个字符分布地均匀即是最优的

通过这个我们可以得到最后答案的长度n，稍微手算一下大概是150这个级别的，然后再考虑让字典序最小

这个问题算是经典套路了吧，我们从前往后枚举每一位，然后从小到大枚举这一位上放的数，接下来就是要求出在一段前缀确定的情况下后面能产生的最大逆序对数是多少

根据前面的分析我们知道后面这一段一定是单调不增的，那么我们很容易考虑由此设计DP状态

令fi,j,k表示处理了后面的第i个位置，其中第i个位置是字符j，最后一段连续的字符j的长度为k时，产生的最大逆序对数目

我们记bktx表示前面确定了的那段前缀中，大于字符x的数目，则很容易列出转移方程：

fi+1,j,k+1=max(fi+1,j,k+1,fi,j,k+i−k+bktj)fi+1,j−1,1=max(fi+1,j−1,1,fi,j,k+i+bktj−1)

然后写完交一发，喜提82pts，小TLE两个点，仔细一算复杂度1503×262好像确实跑不太动（20多亿吧好像）

然后各种尝试优化无果，最后只能去看了眼Solution，这里先放一下DP的代码

#include<cstdio>
#include<iostream>
#include<cstring>
#define RI register int
#define CI const int&
using namespace std;
const int N=150;
int tot,n,ret,bkt[N],f[N][26][N]; char ans[N];
inline int check(CI n)
{
	RI i,j,k; for (memset(f,0,sizeof(f)),i=0;i<26;++i) f[1][i][1]=bkt[i];
	for (i=1;i<n;++i) for (j=0;j<26;++j) for (k=1;k<=i;++k)
	{
		f[i+1][j][k+1]=max(f[i+1][j][k+1],f[i][j][k]+i-k+bkt[j]);
		if (j) f[i+1][j-1][1]=max(f[i+1][j-1][1],f[i][j][k]+i+bkt[j-1]);
	}
	int cur=0; for (j=0;j<26;++j) for (k=1;k<=n;++k)
	cur=max(cur,f[n][j][k]); return cur;
}
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	RI i,j,k; for (scanf("%d",&tot),i=1;;++i) if (check(i)>=tot) { n=i; break; }
	for (i=1;i<=n;++i) for (j=0;j<26;++j)
	{
		for (ret+=bkt[j],k=0;k<j;++k) ++bkt[k];
		if (check(n-i)+ret>=tot) { ans[i]=j+'a'; break; }
		for (ret-=bkt[j],k=0;k<j;++k) --bkt[k];
	}
	for (i=1;i<=n;++i) putchar(ans[i]); return 0;
}

Solution的意思是说我们在算后面那部分最大的逆序对数的时候，每个位置填什么其实只要贪心地确定下来即可

因为只要满足这一位填上去带来的可能的逆序对数最大，换做其它的方法一定不会更优

这样复杂度就少了一个150，可以轻松跑过

#include<cstdio>
#include<iostream>
#include<cstring>
#define RI register int
#define CI const int&
using namespace std;
const int N=150;
int tot,n,ret,bkt[N],c[26]; char ans[N];
inline int check(CI n,int cur=0)
{
	RI i,j; for (memset(c,0,sizeof(c)),i=1;i<=n;++i)
	{
		int mx=-1,pos=0; for (j=0;j<26;++j)
		if (i-1-c[j]+bkt[j]>mx) mx=i-1-c[j]+bkt[j],pos=j;
		cur+=mx; ++c[pos];
	}
	return cur;
}
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	RI i,j,k; for (scanf("%d",&tot),i=1;;++i) if (check(i)>=tot) { n=i; break; }
	for (i=1;i<=n;++i) for (j=0;j<26;++j)
	{
		for (ret+=bkt[j],k=0;k<j;++k) ++bkt[k];
		if (check(n-i)+ret>=tot) { ans[i]=j+'a'; break; }
		for (ret-=bkt[j],k=0;k<j;++k) --bkt[k];
	}
	for (i=1;i<=n;++i) putchar(ans[i]); return 0;
}

11|0荒岛探测


题目啰了一大堆，核心其实就一句话——求一个椭圆和一个三角形的公共部分的面积

对于这种曲线图形和多边形求面积的问题，一般是没有绝对精确的算法的，然后这题精度要求也不高，显然可以直接手动用微元法来分割求面积

但是如果直接上的话会有一个问题，在已知x坐标的情况下我们解不出和椭圆的交点的y坐标（用牛顿迭代太麻烦）

那么处理方法也很容易，把坐标系旋转再平移，把椭圆变成标准形即可

具体写的时候我取Δx=10−4，直接一发入魂

#include<cstdio>
#include<iostream>
#include<cmath>
#define RI register int
#define CI const int
using namespace std;
const double EPS=1e-4;
struct Point
{
	double x,y;
	inline Point(const double& X=0,const double& Y=0)
	{
		x=X; y=Y;
	}
	inline friend Point operator + (const Point& A,const Point& B)
	{
		return Point(A.x+B.x,A.y+B.y);
	}
	inline friend Point operator - (const Point& A,const Point& B)
	{
		return Point(A.x-B.x,A.y-B.y);
	}
	inline friend Point operator * (const Point& A,const double x)
	{
		return Point(A.x*x,A.y*x);
	}
	inline friend Point operator / (const Point& A,const double x)
	{
		return Point(A.x/x,A.y/x);
	}
	inline void rotate(const double& ang)
	{
		double tx=x,ty=y; x=tx*cos(ang)-ty*sin(ang); y=tx*sin(ang)+ty*cos(ang);
	}
}O1,O2,T1,T2,T3; double l,a,b,ans;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	scanf("%lf%lf%lf%lf%lf",&O1.x,&O1.y,&O2.x,&O2.y,&l);
	scanf("%lf%lf%lf%lf%lf%lf",&T1.x,&T1.y,&T2.x,&T2.y,&T3.x,&T3.y);
	double ang=-atan2(O1.y-O2.y,O1.x-O2.x);
	O1.rotate(ang); O2.rotate(ang); T1.rotate(ang); T2.rotate(ang); T3.rotate(ang);
	Point O=(O1+O2)/2.0; O1=O1-O; O2=O2-O; T1=T1-O; T2=T2-O; T3=T3-O;
	a=l/2; b=sqrt(a*a-O1.x*O1.x);
	if (T2.x>T3.x) swap(T2,T3); if (T1.x>T2.x) swap(T1,T2); if (T2.x>T3.x) swap(T2,T3);
	double k1=(T1.y-T2.y)/(T1.x-T2.x),b1=T1.y-k1*T1.x;
	double k2=(T2.y-T3.y)/(T2.x-T3.x),b2=T2.y-k2*T2.x;
	double k3=(T1.y-T3.y)/(T1.x-T3.x),b3=T3.y-k3*T3.x;
	for (double x0=-a;x0<=a;x0+=EPS)
	{
		double l1=-b*sqrt(1.0-x0*x0/(a*a)),r1=b*sqrt(1.0-x0*x0/(a*a)),l2,r2=k3*x0+b3;
		if (T1.x<=x0&&x0<=T2.x) l2=k1*x0+b1; else
		if (T2.x<=x0&&x0<=T3.x) l2=k2*x0+b2; else l2=r2=0;
		if (l2>r2) swap(l2,r2); l1=max(l1,l2); r1=min(r1,r2);
		if (l1<=r1) ans+=(r1-l1)*EPS;
	}
	return printf("%.2lf",ans),0;
}

据说这题还有一种蒙特卡洛算法，就是随机取点，然后统计落在不同区域内的次数，最后比一下就得到一个近似的答案，感觉还是很有意思的，不过我懒得写了

12|0Postscript


今天晚上还要打CF，明天早上上日语晚上开组会，这个礼拜也只能堪堪做一套题了


__EOF__

本文作者：hl666
本文链接：https://www.cnblogs.com/cjjsb/p/17231562.html
关于博主：复活的ACM新生，目前爱好仅剩Gal/HBR/雀魂/单机/OSU
版权声明：转载请注明出处
声援博主：欢迎加QQ：2649020702来DD我
posted @   空気力学の詩  阅读(160)  评论(0)  编辑  收藏  举报
相关博文：
· 2022年第十三届蓝桥杯大赛软件类省赛C/C++大学A组真题
· 2021年第十二届蓝桥杯大赛软件类决赛C/C++大学A组真题
· 第十一届蓝桥杯大赛第二场省赛试题A组C++&C
· 2020蓝桥杯c语言省赛B组
· 第六届蓝桥杯大赛个人赛省赛真题C++A组，B组，C组真题解析
阅读排行：
· 终于写完轮子一部分：tcp代理 了，记录一下
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
点击右上角即可分享
微信分享提示