临时抱佛脚之第十一届蓝桥杯国赛B组部分题解(Part 1)

前言

酒可真是好东西啊，能让人一时间忘记不快的事。
但是一到明天就算不喜欢也还是会想起，而且比昨天更让人痛苦，想逃也逃不掉。 ——坂田银时

题目来源

蓝桥杯官网→学习资料→历届真题→竞赛→蓝桥杯真题

A.美丽的2

没什么好说的，暴力就完事了。

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int cnt=0;
    for(int i=1;i<=2020;i++){
        int x=i;
        while(x){
            int m=x%10;
            if(m==2){
                cnt++;
                break;
            }
            x/=10;
        }
    }
    cout<<cnt<<endl;
}

B.扩散

用BFS（广度优先搜索）就可以解决。

不过要注意的是如果以(0,0)为起点，黑点是会扩散到第2,3,4象限（有负值）。

所以我们改变一下坐标轴的相对位置，把这四个点统统上移。
（量不重要，只要保证不会在染色时染到其他象限即可）

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int x,y,t;
    node() {}
    node(int xx,int yy,int tt):x(xx),y(yy),t(tt) {}
};
int a[10000][10000];
int dx[4]= {1,-1,0,0};
int dy[4]= {0,0,1,-1};
int ans;
void bfs()
{
    queue<node> q;
    q.push(node(0+2500,0+2500,0));
    q.push(node(2020+2500,11+2500,0));
    q.push(node(11+2500,14+2500,0));
    q.push(node(2000+2500,2000+2500,0));
    a[0+2500][0+2500]=1;
    a[2020+2500][11+2500]=1;
    a[11+2500][14+2500]=1;
    a[2000+2500][2000+2500]=1;
    while(!q.empty())
    {
        node tmp=q.front();
        q.pop();
        if(tmp.t==2020) break;
        for(int i=0; i<4; i++)
        {
            int xx=tmp.x+dx[i];
            int yy=tmp.y+dy[i];
            if(!a[xx][yy])
            {
                a[xx][yy]=1,ans++;
                //cout<<xx<<" "<<yy<<" "<<tmp.t+1<<endl;
                q.push(node(xx,yy,tmp.t+1));
            }
        }
    }
}
int main()
{
    ans=4;
    memset(a,0,sizeof(a));
    bfs();
    cout<<ans<<endl;
}

C.阶乘约数

这个就有点意思了。
首先要先了解一个东西：唯一分解定理。

度娘上东西有点多，我把我们这题所要用到的提取了出来：

一个大于1的正整数N，如果它的标准分解式为N=(p1^a1) * (p2^a2)* …* (pn^an)
(p1<p2<…<pn且都为素数),
那么它的正因数个数为F(N)=(1+a1) * (1+a2) * …*(1+an)。

知道这个之后这题思路就清晰了：
100！是从1乘到100，那么我们把每个数的分解式都求出来，然后乘起来就能得到100！的标准分解式。
（附：a^x * a^y =a^x+y）

#include<bits/stdc++.h>
using namespace std;
int prime[1000];
bool is_prime[1000];

void oula()
{
    prime[0]=0;
    memset(is_prime,false,sizeof(is_prime));
    is_prime[0]=is_prime[1]=true;
    for(int i=2;i<=1000;i++){
        if(!is_prime[i]){
            prime[++prime[0]]=i;
            for(int j=1;j<=prime[0];j++){
                if(i*prime[j]>1000) break;
                is_prime[i*prime[j]]=true;
                if(i%prime[j]==0) break;
            }
        }
    }
}
int main()
{
    oula();
    map<int,int> q;
    for(int i=2;i<=100;i++){
        int l=1;
        int x=i;
        while(l<=prime[0]&&x){
            if(x%prime[l]==0){
                q[prime[l]]++;
                x/=prime[l];
            }
            else l++;
        }
    }
    map<int,int>::iterator it;
    long long ans=1;  //开longlong，不然会爆掉
    for(it=q.begin();it!=q.end();it++){
        ans*=(it->second+1);
    }
    cout<<ans<<endl;
}

D.本质上升序列

题意不难理解，对于这道题的解法也有很多。

我这里用的是BFS+Set集合存结果，每次存的时候都要查重一下。
最后只要看一下Set集合的大小就ok。

缺点就是耗时高，如果是编程题，1000%的会T掉。

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
struct node
{
    string s;
    int pos;
    node() {}
    node(string ss,int p):s(ss),pos(p) {}
};
string ques="tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl";
set<string> answer;
void bfs()
{
    queue<node> q;
    int len=ques.size();
    for(int i=0; i<len; i++)
    {
        string sss="";
        sss+=ques[i];
        if(answer.find(sss)==answer.end())
        {
            q.push(node(sss,i));
            answer.insert(sss);
        }
    }
    while(q.size())
    {
        string ss=q.front().s;
        int pos=q.front().pos;
        q.pop();
        for(int i=pos+1; i<len; i++)
        {
            if(ques[i]>ques[pos]&&answer.find(ss+ques[i])==answer.end())
            {
                answer.insert(ss+ques[i]);
                q.push(node(ss+ques[i],i));
            }
        }
    }
    cout<<answer.size()<<endl;
}
int main()
{
    bfs();
}

E.玩具蛇

DFS（深度优先搜索）。
做法就是以每一个格子为出发点，寻找在出发点固定的情况下能够放置的最大方案数。

难度远远低于B题。

#include<iostream>
#include<algorithm>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;

const int maxn=3e5+100;

bool vis[4][4];
int cnt;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
void dfs(int x,int y,int ans)
{
    if(ans==16){
        cnt++;
        return;
    }
    for(int i=0;i<4;i++){
        int xx=x+dx[i];
        int yy=y+dy[i];
        if(xx<4&&xx>=0&&yy<4&&yy>=0){
            if(!vis[xx][yy]){
                vis[xx][yy]=true;
                dfs(xx,yy,ans+1);
                vis[xx][yy]=false;
            }
        }
    }
}

int main(){
    cnt=0;
    memset(vis,false,sizeof(vis));
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            vis[i][j]=true;
            dfs(i,j,1);
            vis[i][j]=false;
        }
    }
    cout<<cnt<<endl;
}

剩下的题目，

下次亿定！