蓝桥杯第一次阶段性考核题解

马上就要蓝桥杯了兄弟们，实验室第一次考核直接跟上

所有题解都使用c++编写，没有严格按照代码标准格式，别介意哈

那我们直接开始吧

一、A+B problem

签到题不多说了

代码：

#include<iostream>
using namespace std;
int main(){
	int a,b;
	cin>>a>>b;
	cout<<a+b;
}

二、两数之和

这题问题也不大

代码：

#include<iostream>
using namespace std;
int main(){
	int n;
    int arr[10000];
    cin>>n;
    //获取数组数据
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    int target;
    cin>>target;
    for(int i=0;i<n;i++){
        //用j=i可以快好多，避免a+b和b+a的重复运行
        for(int j=i;j<n;j++){
            //避免重复
            if(i!=j){
                if(arr[i]+arr[j]==target){
                    cout<<i<<' '<<j;
                }
            }
        }
    }
}

三、级数求和

整体思路就是用循环从1加到1/n，大于k的时候退出循环就行

比较值得关注的是除数要强制转化为double，否则整体会转化为整形

代码：

#include<iostream>
using namespace std;
int main(){
	double k;
    cin>>k;
    //x设为long long int防爆
    long long int x=1;
    double sum=0;
    while(sum<=k){
        //注意隐形类型转换
        sum+=1.0/(double)x;
        x++;
    }
    cout<<x-1;
}

四、在排序数组中查找元素的第一个和最后一个位置

个人认为比较简单的思路（因为这题有个前提是非递减数组，即有序）就是先遍历数组，当遇到第一个符合要求的数时记录下标i，然后继续遍历直到arr[i]之后的第一个不符合要求的数时记录下标j，输出的答案就是i和j-1；

#include<iostream>
using namespace std;
int main(){
	int n;
    //long long int防爆,担心数组过大可以放到堆里
    long long int arr[100000];
    cin>>n;
    //如果没找到则返回-1，故初始值设为-1
    int ans1=-1,ans2=-1;
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    //long long int防爆
    long long int target;
    cin>>target;
    int j=0;
    //遍历数组
    for(int i=0;i<n;i++){
        if(arr[i]==target){
            ans1=i;
            //继续遍历直到第一个不符合要求的数
            while(arr[i+j]==arr[i]){
                ans2=i+j;
                j++;
            }
            //退出循环节约运行时间
            break;
        }
    }
    cout<<ans1<<' '<<ans2;
}

五、找出数组中的 K-or 值

个人认为是除最后一题外最不好做的一题，难点在读题（可能是我阅读理解太差）

整体意思就是使用AND位与运算符判断是否符合第i位为一的要求

（AND在c++中即为&）

很重要的一点就是：位与运算符获得的值要用一个变量来接收，不能直接放入表达式内

（这里要感谢某位翟姓学长发现题目错误，不然不知道要卡多久）

举个例子：

//错误
cout<<i & x==i;

//正确
a=i & x;
cout<<a==i;

代码：

#include<iostream>
#include<math.h>
using namespace std;
int main(){
	int n;
    int arr[100];
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }
    int k;
    cin>>k;
    int num[8];
    for(int i=0;i<8;i++){
        num[i]=0;
    }
    int x,y;
   	for(int i=0;i<n;i++){
        //题干给的判断方法
        for(int j=0;j<8;j++){
            y=pow(2,j);
            //使用变量接收
            x=y & arr[i];
            if(x==y){
                num[j]++;
            }
        }
    }
    int sum=0;
    for(int i=0;i<8;i++){
        if(num[i]>=k){
            sum+=pow(2,i);
        }
    }
    cout<<sum;
}

六、岛屿数量

上学期实验室与研发室一起考核的题，可给木木学长气的

说一下大致思路吧

深度优先（DFS）一定是要会的，其次就是一些变通

我们先创建一个比给定长宽都大2的二维数组模拟图，再假定所有点都是水（即0），然后输入陆地位置（即1），这样的图就是有一圈水包围的题干给的图（方便判断）

接下来通过深度优先把每个岛屿淹没（即1变0），每淹没一个岛屿就把岛屿总数+1

最后输出总数就好啦

上代码：

#include<iostream>
using namespace std;
int arr[302][302];
int X[4]={1,0,-1,0};
int Y[4]={0,1,0,-1};

//深度优先算法把岛屿淹没
void fun(int x,int y){
    arr[x][y]=0;
    for(int i=0;i<4;i++){
        if(arr[x+X[i]][y+Y[i]]==1){
            arr[x+X[i]][y+Y[i]]=0;
            fun(x+X[i],y+Y[i]);
        }
    }
}

int main(){
    int n,m;
    cin>>n>>m;
    //创建一个长宽都大2的图
    for(int i=0;i<n+2;i++){
        for(int j=0;j<m+2;j++){
            arr[i][j]=0;
        }
    }
    //输入样例给的图
    for(int i=1;i<n+1;i++){
        for(int j=1;j<m+1;j++){
           	cin>>arr[i][j];
        }
    }
    int sum=0;
    //查找是否还有陆地，有的话把它淹了
    for(int i=0;i<n+2;i++){
        for(int j=0;j<m+2;j++){
            if(arr[i][j]==1){
                fun(i,j);
                sum++;
            }
        }
    }
    cout<<sum;
}

七、找出字符串的可整除数组

这题我问了好多人，给我的感觉就是想的太复杂了，直接按着题目意思做就行，只要能用代码完全正确表达题干意思就至少能得70%的分，剩下的就是算法优化的问题了（数组太小，long long int ，时间复杂度太高之类的问题）

简单讲一下思路

首先获取的是一个字符串，我们只要把每一段数取出来，再判断能否整除，再把得出的答案放入数组依次输出就可以了

但是中间有很大的优化空间

第一个困扰很多人的是怎么更快的把每一段数取出来，最简单的就是嵌套循环，前n个数通过x=x*10+(int)(str[i]-'0')的方式取出，但这样的时间复杂度是O（n^2），很显然慢了点（具体能不能过我也没试过）

我的方法是只用一次循环，每次只取一个字符，在上一次的基础上通过x=x*10+(int)(str[i]-'0')增加，而非从头再加一次，省去了不少重复的步骤，但是要把判断能否整除的过程放在循环中进行

第二个可以优化的是把最后存储答案的数组省略掉，我们可以在判断的过程中直接输出每一次判断的答案，省去了存入数组再取出来的时间，但要注意格式的问题！！！

上代码：

#include<iostream>
using namespace std;
int main(){
	string str;
    cin>>str;
    int m;
    cin>>m;
    //字符串有点长，开long long int防爆
    long long int x=0;
    int n=str.length();
    //依次取出字符
    for(int i=0;i<n;i++){
        //一个个往上加
        x=x*10+(int)(str[i]-'0');
        //直接判断加输出
        if(i!=n-1){
            if(x%m==0){
                cout<<1<<' ';
            }else{
                cout<<0<<' ';
            }
        }else{
            //最后输出结尾没有空格（注意！！！）
            if(x%m==0){
                cout<<1;
            }else{
                cout<<0;
            }
        }
    }
}

八、到达目的地的方案数

我是fw

又要感谢某位翟姓学长给的题解，神！！！

上代码：

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e3+5;
struct Edge{
    ll x,w;//x表示下一个点，w表示到下一个点的距离
    bool operator <(const Edge&v)const//重载<运算符
    {
        if(x!=v.x) return v.x<x;//再其次考虑点
        return v.w<w;//优先考虑距离，实现逆序排列
    }
};
const int N = 1e5;
vector<Edge> g[N];
//利用邻接表来存储矩阵，什么你知道有那些存储图的方法，那么我必须给你推荐一手我的博客
//http://nicedream18.cn/index.php/2024/02/29/1-2/
//(o≖◡≖)这篇博客总结了几种存图方式，最为推荐的就是我这次使用的邻接表的存储方式
int d[N];//记录各个点到起点的距离
int way[N];//用于记录到各个点的路径个数
//下面是dijkstra的板子，我写的这个是经过堆优化的，也有较为基础的版本
//下面又不得不推荐我的博客了
//http://nicedream18.cn/index.php/2024/03/03/dijkstra/
//这篇对于dijkstra算法的基本原理和板子进行了讲解，那下面这段大部分就不细讲了
void dijkstra(int st)
{
    way[0] = 1;//将开始的地方距离定为1
    memset(d,0x3f,sizeof(d));
    d[st] = 0;
    bitset<N> vis;
    priority_queue<Edge> pq;
    pq.push({st,d[st]});
    while(pq.size()){
        ll x = pq.top().x;
        ll w = pq.top().w;
        pq.pop();
        if(vis[x])continue;
        vis[x] = true;
        for(auto &[y,w]:g[x]){
            if(d[y]>d[x]+w){
                d[y] = d[x]+w;
                way[y] = way[x];//将到达的路径数量进行更新
                pq.push({y,d[y]});
            }else if(d[y]==d[x]+w)
            {
                way[y] = (way[x]+way[y])%mod;//将两条路相加
            }
        }
    }
}
int main(){
    int n;
    cin>>n;
    int m;
    cin>>m;
    for(int i =1;i<=m;i++){
        int u,v,w;
        cin>>u>>v>>w;
        g[u].push_back({v,w});
        g[v].push_back({u,w});
    }
    dijkstra(0);
    cout<<way[n-1];//输出n-1个点的路径数
}