第十三届蓝桥杯B组省赛比赛心路历程

前言

感觉题量还是有点大，主要是老是想着骗分，就没去想正解，然后搜索又写不好，浪费了很多时间，下面就浅谈一下今年题目吧。本人略菜，解析仅供参考（大概率我错了）。

A题：九进制转十进制

1478

送分题

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int ans=2*1+2*9+2*9*9*9;
	cout<<ans<<endl; 
} 

14

感觉题意有点歧义，好多人好像不算012这样的顺子，算了是14，不算好像是4.因为234不可能出现，所以考虑012，123这几种情况就好了，可以翻日历，我当时就看到日期，就枚举了，没咋想。思路就是转成字符串然后判断。感觉不如直接数着来的快。

#include<bits/stdc++.h>
using namespace std;
int month[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
string getDay(int mo,int da)
{
	string s="2022";
	if(mo<=9)
	{
		s+='0';
		s+=('0'+mo);
	}
    else 
    {
    	int fmo=mo%10,smo=mo/10;
    	s+=(smo+'0');
    	s+=(fmo+'0');
    }
    if(da<=9)
	{
		s+='0';
		s+=('0'+da);
	}
    else 
    {
    	int fda=da%10,sda=da/10;
    	s+=(sda+'0');
    	s+=(fda+'0');
    }
    
    return s;
}
int main()
{   
    int ans=0;
	for(int i=1;i<=12;i++)
	{
		for(int j=1;j<=month[i];j++)
		{
			//cout<<getDay(i,j)<<endl;
			string day=getDay(i,j);
			for(int k=0;k<day.size()-2;k++)
			{
			   if(day[k]==day[k+1]-1&&day[k+1]==day[k+2]-1)
			   {
			   	 cout<<i<<" "<<j<<" "<<day<<endl;ans++;
			   	 break;
			   }
			} 
		}
	}
	cout<<ans<<endl;
}

简单签到

个人的做法是先算整个7天的，这个直接下取整就可以了，然后剩余至多7天，一个循环找一下是哪一天，可以推公式，但是这样写比较稳妥吧

#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
	 ll a,b,n;
	cin>>a>>b>>n;
	ll oneweek=5*a+2*b;
	ll need=n/oneweek;
     ll mod=n-need*oneweek;
	//cout<<a<<" "<<b<<" "<<need<<" "<<oneweek<<" "<<endl;
	ll ans=need*7;
	for(int i=1;i<=7;i++)
	{    
	    if(mod<=0)break;
		if(i>=1&&i<=5)
		{
			if(mod>a)mod-=a;
			else {
				ans++;break;
			}
		}
		else 
		{
			if(mod>b)mod-=b;
			else {
				ans++;break;
			}
		}
		ans++;
		if(mod<=0)break;
	}
	cout<<ans<<endl;
	return 0;
	
}

暴力、思维

暴力的做法就是来回走三趟，O（n）不会t，其实可以发现左右对称，计算一下一个来回的时间，取个大的来回就好了。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;cin>>n;
	for(int i=1;i<=n;i++)
	{   
	    int ans=i;
		ans=max(ans,2*(n-i));
		ans=max(ans,2*(i-1));
		cout<<ans<<endl; 
	}
}

无语

被这道题卡了，因为一开始读题读不懂，然后写了dfs骗分，骗分的思路就是枚举所有进制的情况，正解其实不难想，进制确定的情况下，每个数的权重也确定了，因为A一定大于B，所以A的最高位一定不会比B小。所以要让最终的base尽量小。简单来说就是在满足条件的情况下，选择较小的进制就可以了。就是要不懂两个数是不是位数会不一样啊？给个Ma、Mb做什么，我就处理了一下两个数字，变成一样长，反之补0，写的非常丑。慎看

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll A[100005],B[100005],rA[100005],rB[100005];
int st[10005],n,num[10005];
ll mi=1e18;
void dfs(int step,int len)
{
	if(step==len+1)
	{   
	    
		ll base=1;
		ll nowa=0,nowb=0;
		for(int i=1;i<=len;i++)
		{
		   nowa+=rA[i]*base;
		   base*=num[i];
		}
		base=1;
		for(int i=1;i<=len;i++)
		{
		   nowb+=rB[i]*base;
		   base*=num[i];
		}
	//	cout<<nowa<<" "<<nowb<<endl;
		mi=min(nowa-nowb,mi);
		return ;
	}
	ll need;
	ll maxn=max(rA[step],rB[step]);
	if(maxn<2)need=2;
	else need=maxn+1;
	for(int i=need;i<=n;i++)
	{   
	    num[step]=i;
		dfs(step+1,len);
	}
}

int main()
{
     cin>>n;
    int ma,mb;cin>>ma;
    for(int i=1;i<=ma;i++)
    cin>>A[i];
    cin>>mb;
    for(int i=1;i<mb;i++)
    cin>>B[i];
    int len=max(ma,mb);
    for(int i=len;i>ma;i--)
    rA[i]=0;
    for(int i=ma;i>=1;i--)
    rA[i]=A[ma-i+1]; 
    for(int i=len;i>mb;i--)
    rB[i]=0;
    for(int i=mb;i>=1;i--)
    rB[i]=B[ma-i+1]; 
    if(n<=11)
    {
    	dfs(1,len);
    }
    else 
    {   
        
        ll base=1;
		ll nowa=0,nowb=0;
		ll need;
		for(int i=1;i<=n;i++)
		{
					
			ll maxn=max(rA[i],rB[i]);
			if(maxn<2)need=2;
			else need=maxn+1;
			num[i]=need;
		}

    	for(int i=1;i<=len;i++)
		{
		   nowa+=rA[i]*base;
		   base*=num[i];
		}
		base=1;
		for(int i=1;i<=len;i++)
		{
		   nowb+=rB[i]*base;
		   base*=num[i];
		}

		mi=min(nowa-nowb,mi);
    }
    cout<<mi;
   
}

不会

二维前缀和n^4次方骗分了，没啥好讲的，前缀和处理一下，然后枚举左上角和右下角的坐标，可以想到的优化的点就是将已经超过k的子矩阵的其它包含这个矩阵直接不要计算，跳出循环

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[1005][1005],sum[1005][1005];
ll getsum(int x1,int y1,int x2,int y2)
{
	return sum[x2][y2]+sum[x1-1][y1-1]-sum[x1-1][y2]-sum[x2][y1-1];
}
int main()
{
	int n,m,k;cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{  
		    ll x;cin>>x;
			sum[i][j]=sum[i-1][j]+sum[i][j-1]+x-sum[i-1][j-1];
		}
	}
    int ans=0;
    for(int x1=1;x1<=n;x1++)
    for(int y1=1;y1<=m;y1++)
    for(int x2=x1;x2<=n;x2++)
    for(int y2=y1;y2<=m;y2++)
    {
       if(getsum(x1,y1,x2,y2)<=k)
	   {  
	      ans++;
	   }
	   //cout<<getsum(x1,y1,x2,y2)<<" "<<x1<<" "<<y1<<" "<<x2<<" "<<y2<<endl;
    }
    cout<<ans<<endl;
    
}

DP

就预处理一下21矩阵，22矩阵，23矩阵，24矩阵的最小情况，然后n>=5的时候就是递推了
状态转移方程F[i]=2F[i-1]+3F[i-3]；
一开始把N看成1e9了，还想着写矩阵加深然后滚动数组优化一下。。。。。。。
结果是原题。。。

看着怪裸，但是不会

就骗了骗分，过了样例就交了，维护一个队列，里面放着当前已经引爆的炸弹，圆形就是矩形扣掉四个点就好了。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=50005;
int st[N];
struct node{
	ll x,y,r;
}e[N],pe[N];
int check(int id,ll x1,ll y1,ll x2,ll y2 )
{  
     ll i=e[id].x,j=e[id].y;
	if((i==x1&&j==y1)||(i==x1&&j==y2)||(i==x2&&j==y1)||(i==x2&&j==y2))return 0;
	else if(i>=x1&&i<=x2&&j>=y1&&j<=y2)return 1;
	return 0;
}
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	 {
	 	cin>>e[i].x>>e[i].y>>e[i].r;
	 }
    queue<node>pm;
	for(int i=1;i<=m;i++)
	 {
   	   node t;cin>>t.x>>t.y>>t.r;
   	   pm.push(t); 
     } 
     int ans=0;
	 while(pm.size())
	 {
	 	node now=pm.front();
	 	pm.pop();
	 	ll x1=now.x-now.r,x2=now.x+now.r,y1=now.y-now.r,y2=now.y+now.r;
	 	for(int i=1;i<=n;i++)
	 	{
	 		if(!st[i]&&check(i,x1,y1,x2,y2))
	 		{
	 			pm.push(e[i]);
	 			st[i]=1;
	 			ans++;
	 		}
	 	}
	 }
	 cout<<ans<<endl;
	
}

骗分

直接dfs枚举，2^10,拿下百分之30

没看，听说很容易骗分。