蓝桥杯2020C++B组

锦素流年58

已于 2023-02-24 16:57:42 修改

阅读量398

点赞数 2

文章标签： c++ 蓝桥杯算法 Powered by 金山文档

于 2023-02-22 23:13:25 首次发布

本文链接：https://blog.csdn.net/qq_61090079/article/details/129158427

版权

本文介绍了多种编程问题的解决方案，包括使用for循环统计数字2的出现次数，计算最大公约数的欧几里得算法和递归方法，七段码的DFS和并查集解决策略，以及日期处理、成绩统计、子串分值和的计算方法，最后讨论了平面切分问题的规律和算法实现。

摘要由CSDN通过智能技术生成

门牌制作:

先利用for循环枚举从1到2020的每一个数字，然后对该数字每位求余，sum统计最后的结果输出

，答案是624。

代码：

#include<iostream>
using namespace std;
int main(){
    int sum=0;
    for(int i=1;i<=2020;i++){
        int num=i;
        while(num){
            if(num%10==2){
                sum++;
            }
            num/=10;
        }
    }
    cout<<sum;
    return 0;
}

既约分数：

最大公约数（greatest common divisor ,简称GCD）：

两种求法：(证明方法不再赘述)

欧几里得算法：gcd(a,b)=gcd(b,a mod b)时间复杂度为log n

a=117,b=68
a/b=117/68=1……47
68/47=1……21
47/21=2……5
21/5=4……1
5/1=5……0
最大公约数为0

非递归算法(C++)



    int a,b,r;
    cin>>a>>b;
    while(b){
        temp=a;
        a=b;
        b=temp%b;
    }
    cout<<a<<endl;//最后返回的a的值是最后一次保存的b的值，a的值用中间变量保存了。

递归算法：


int gcd(int a,int b){
    if(b==0)return a;
    return gcd(b,a%b);
}

不过c++有自带的函数：__gcd(a,b)头文件是algorithm

这题就是两层for循环枚举，然后用gcd统计互为素数组的个数

code

#include<iostream>
using namespace std;
int main(){
    int sum=0;
    for(int i=1;i<=2020;i++){
        int num=i;
        while(num){
            if(num%10==2){
                sum++;
            }
            num/=10;
        }
    }
    cout<<sum;
    return 0;
}

蛇形填数

找规律：（称n行n列的数为n数）发现2数到3数之间差了一个斜队+2数剩下的部分+3数斜行的一半

可以发现，除了第一行之外都是这种规律：

代码：

#include<iostream>
using namespace std;
int main(){
    int num=5,kk=2;
    for(int i=3;i<=100000;i+=2){
        num+=i/2+(i+1)+(i+3)/2;
        kk++;
        if(kk==20)break;//到需要的数就退出循环
    }
    cout<<num;
    return 0;
}

七段码：

DFS+并查集：

建边别建错了，看好久orz~

#include<iostream>
using namespace std;
int map1[10][10],fa[10],ans;
bool used[10];
inline void init(){
    //建边
    map1[0][5]=map1[5][0]=map1[0][1]=map1[1][0]=1;//a到b,a到f建边
    map1[1][6]=map1[6][1]=map1[1][2]=map1[2][1]=1;//b到g，b到c
    map1[2][3]=map1[3][2]=map1[2][6]=map1[6][2]=1;//c到d
    map1[3][4]=map1[4][3]=1;
    map1[4][6]=map1[6][4]=map1[4][5]=map1[5][4]=1;
    map1[5][6]=map1[6][5]=1; 
}
int find(int x){
    if(fa[x]==x)return x;
    else return find(fa[x]);
}
inline void merge(int a,int b){
    fa[find(a)]=find(b);
}
void dfs(int u){
    //终止条件
    if(u>6){
        int k=0;
        for(int i=0;i<=6;i++)fa[i]=i;
        for(int i=0;i<7;i++){
            for(int j=0;j<7;j++){
                if(map1[i][j]&&used[i]&&used[j]){//判断联通，是否是亮的 
                    if(find(i)!=find(j))merge(i,j);//如果不是一个根，就合并 
                }
            }
        }
        for(int i=0;i<7;i++){
            if(used[i]&&fa[i]==i)k++;//如果是亮的且根是自己，如果最后k为1,就是一个连通图案 
        } 
        if(k==1)ans++;
        return ;
    }
    //选或者不选
    used[u]=1;
    dfs(u+1);
    used[u]=0;
    dfs(u+1); 
}
int main(){
    init();
    dfs(0);
    cout<<ans;
    return 0;
}

跑步锻炼：

第一眼看上去很复杂，其实我们可以用一个date类来综合所有的数据：年、月、日和周几（为了防止命名冲突使用的ans做类名）,getY()、getM()、getD()分别用来获取当前的年、月、日。在公有部分设计一个日期叠加的成员函数和统计每天跑的日期的成员函数，用静态变量保存答案。

代码：

#include<iostream>
using namespace std;
class ans{
    private:
        int y;
        int m;
        int d;
        int t;
    public:
        static int sum;
        ans(int y,int m,int d,int t){
            this->y=y;
            this->m=m;
            this->d=d;
            this->t=t;
        }
        void add(){
            t++;
            if(t%8==0){
                t=1;
            }
            if(m==4||m==6||m==9||m==11){
                if(d<=29)d++;
                else{
                    d=1;
                    m++;
                }
            }else if(m==2){
                if(y%400==0||(y%4==0&&y%100!=0)){
                    if(d<=28)d++;
                    else d=1,m++;
                }else{
                    if(d<=27)d++;
                    else d=1,m++;
                }
            }else{
                if(d<=30)d++;
                else{
                    if(m==12){
                        y++;
                        m=1;
                        d=1;
                    }else{
                        m++;
                        d=1;
                    }
                }
            }
        }
        void askans(){
            if(d==1||t==1)sum+=2;
            else sum+=1;
        }
        int gety(){
            return y;
        }
        int getm(){
            return m;
        }
        int getd(){
            return d;
        }
};
int ans::sum=0;
int main(){
    ans A(2000,1,1,6);
    for(int i=0;i<=10000;i++){
        if(A.gety()==2020&&A.getm()==10&&A.getd()==2)break;//因为都是包含两头的日期，所以要到日期的下一天截止
        A.askans();
        A.add();
    }
    cout<<A.sum;
}

成绩统计：

用一层for循环遍历输入的每一个数，if判断是否及格/优秀,之后除总人数，利用c++自带的round函数实现四舍五入功能，最后输出结果。（round函数的头文件是math.h)

代码：

#include<iostream>
#include<math.h>
using namespace std;
int main(){
    double  n,cnt,sum1=0,sum2=0,a;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a;
        if(a>=60){
            sum1++;
        }
        if(a>=85){
            sum2++; 
        }
    }
    int ans1=round(sum1/n*100);
    int ans2=round(sum2/n*100);
    printf("%d%\n",ans1);
    printf("%d%%",ans2);
    return 0;
}

子串分值和：

演示下样例：

a=1
ab=2
aba=2
abab=2
ababc=3
 b=2
 ba=2
 bab=2
 babc=3
  a=1
  ab=2
  abc=3
   b=1
   bc=2
    c=1
sum=28

朴素解法：

我们可以发现：总字符串ababc具有ababc,babc,abc,bc和c这五个子串，对于每一个子串（例如ababc),它的总贡献值=a的贡献*(字符串总长度-a出现的位置)+b的贡献*（字符串总长度-b出现的位置）+（……）+c的贡献*（字符串总长度-c出现的位置）,如果在一个字符串中某字符之前出现过一次，那么它的贡献就为零。

代码：

#include<iostream>
#include<stdlib.h>
using namespace std;
bool used[27];
int main(){
    long long int sum=0;
    string str;
    cin>>str;
    int n=str.length();//防止for循环中一次次调用leng()消耗时间
    for(int i=0;i<n;i++){
        for(int k=0;k<27;k++)used[k]=0;//统计各个子串中字符是否重复，所以要初始化
        for(int j=i;j<n;j++){
            if(!used[str[j]-'a']){
                sum+=(str.length()-j);
                used[str[j]-'a']=1;
            }
        }
    }
    cout<<sum;
    return 0;
}

但是这题的数据范围是1e5,我这种算法明显超时了：

考虑它的优化，我们可以把一个总的长度为n的字符串分成n个小子串，那是不是能将总的子串看成一个整体呢，从列的角度看：

第一列：a有效出现了5*1次

第二列：b有效出现了4*2次

第三列：a有效出现了3*2次

第四列：b有效出现了2*3次

第五列：c有效出现了1*5次

我们观察上述总结的式子，可以发现一个概念：有效出现次数。

如果将字符串起始坐标设为1，有效次数=当前字符下标-上次同字符下标

所以sum+=（字符串总长度-字符出现的位置）*（有效次数）

代码：

#include<iostream>
#include<stdlib.h>
using namespace std;
int num[100000];
int used[27];
int main(){
    long long int sum=0;
    string str;
    cin>>str;
    int n=str.length(); 
    for(int i=0;i<n;i++){
        sum+=(i-used[str[i]-'a']+1)*(n-i);//i-used[str[i]-'a']+1是为了让字符下标整体向右偏移一个单位
        used[str[i]-'a']=i+1;//这里也是为了下标从零开始
    }
    cout<<sum;
    return 0;
}

平面切分：

找规律：

假设

第二条直线与第一条直线平行时，平面数sum=2+1

第二条直线与第一条直线相交，平面数sum=2+2

(相交于一点时)第三条直线与第一条和第二条直线相交于一点时sum=4+2

总结：每次增加的平面数等于之前交点数+1

我们可以算出斜率和交点坐标，用set去重

代码：

#include<iostream>
#include<utility>
#include<set>
using namespace std;
const int N=1e3+10;
long double A[N],B[N];
pair<long double,long double>P;
int main(){
    long long int sum=2;//先假设一开始就有一条直线出现在平面上 
    set<pair<long double ,long double> >se;
    int n,a,b,i,j;
    cin>>n;
    for(i=0;i<n;i++){
        cin>>a>>b;
        P=make_pair(a,b);
        se.insert(P);
    }
    i=j=0;
    for(set<pair<long double ,long double> >::iterator it=se.begin();it!=se.end();it++){
        A[i++]=it->first;//注意it的意义 
        B[j++]=it->second;
    }
    for(int i=1;i<se.size();i++){//第i条直线和剩下的直线相交 
        set<pair<long double ,long double > >ans1;//此处的set容器一定要在第一个for里定义，因为之后的叠加算不同的交点个数+1都是当前直线对之前直线新的叠加，所以要新定义的set 
        for(int j=i-1;j>=0;j--){
            if(A[i]==A[j])continue;//斜率相同，不计算斜率
            P.first=(B[j]-B[i])/(A[i]-A[j]);
            P.second=(A[i]*B[j]-A[j]*B[i])/(A[i]-A[j]);
            ans1.insert(P);
        }
        sum=sum+ans1.size()+1;
    }
    cout<<sum;
    return 0;
}