蓝桥训练2

最新推荐文章于 2024-07-24 20:44:05 发布

呜呜呜～铁

最新推荐文章于 2024-07-24 20:44:05 发布

阅读量65

点赞数 1

文章标签：算法图论 c++

本文链接：https://blog.csdn.net/qq_52839873/article/details/129869965

版权

文章包含了多个算法问题的解决方案，包括基于翻转硬币的游戏求解最少操作步数，实现二叉树的后序、中序和层次遍历，计算数的约数之和模运算，以及并查集在亲戚关系和集合合并问题中的应用。这些问题展示了递推、树遍历和数学思维在编程中的应用。

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

蓝桥前一周刷题 acwing&&new_oj

题目来源：https://www.acwing.com/activity/content/introduction/2869/

递推

翻硬币

小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：**oo***oooo
如果同时翻转左边的两个硬币，则变为：oooo***oooo
现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？
我们约定：把翻动相邻的两个硬币叫做一步操作。

输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。

输出格式
一个整数，表示最小操作步数

数据范围
输入字符串的长度均不超过100。
数据保证答案一定有解。

输入样例1：

**********
o****o****

输出样例1：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=110;
char s[N],t[N];
int n,a[N],b[N];

int main(){
    scanf("%s%s",s+1,t+1);
    n=strlen(s+1);
    for(int i=1;i<=n;++i)a[i]=s[i]=='*'?1:0;
    for(int i=1;i<=n;++i)b[i]=t[i]=='*'?1:0;
    int res=0;
    for(int i=1;i<n;++i){
        if(a[i]!=b[i]){
            a[i]=!a[i];
            a[i+1]=!a[i+1];
            ++res;
        }
    }
    if(a[n]==b[n])printf("%d\n",res);
    return 0;
}

砖块

n个砖块排成一排，从左到右编号依次为 1∼n。

每个砖块要么是黑色的，要么是白色的。
现在你可以进行以下操作若干次（可以是 0次）：
选择两个相邻的砖块，反转它们的颜色。（黑变白，白变黑）
你的目标是通过不超过 3n
次操作，将所有砖块的颜色变得一致。

输入格式
第一行包含整数 T，表示共有 T组测试数据。
每组数据第一行包含一个整数 n。
第二行包含一个长度为 n的字符串 s。其中的每个字符都是 W 或 B，如果第 i个字符是 W，则表示第 i号砖块是白色的，如果第 i个字符是 B，则表示第 i个砖块是黑色的。

输出格式
每组数据，如果无解则输出一行 −1。
否则，首先输出一行 k，表示需要的操作次数。
如果 k>0，则还需再输出一行 k个整数，p1,p2,…,pk。其中 pi表示第 i次操作，选中的砖块为 pi和 pi+1号砖块。
如果方案不唯一，则输出任意合理方案即可。

数据范围
1≤T≤10，2≤n≤200。

输入样例：

4
8
BWWWWWWB
4
BWBB
5
WWWWW
3
BWB

输出样例：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

const int N=210;
int n,a[N],b[N];
char s[N];

void solve(){
    scanf("%d%s",&n,s+1);
    for(int i=1;i<=n;++i)a[i]=b[i]=(s[i]=='B'?1:0);

    int Bans=0,Wans=0;
    vector<int>A,B;
    for(int i=1;i<n;++i){
        if(a[i]){
            a[i]=!a[i];
            a[i+1]=!a[i+1];
            ++Bans;
            A.push_back(i);
        }
    }
    for(int i=1;i<n;++i){
        if(b[i]==0){
            b[i]=!b[i];
            b[i+1]=!b[i+1];
            ++Wans;
            B.push_back(i);
        }
    }
    if(!a[n]&&b[n]){
        printf("%d\n",min(Bans,Wans));
        if(Bans==min(Bans,Wans))for(int i=0;i<A.size();++i)printf("%d ",A[i]);
        else for(int i=0;i<B.size();++i)printf("%d ",B[i]);
        if(min(Bans,Wans))puts("");
    }
    else if(!a[n]){
        printf("%d\n",Bans);
        for(int i=0;i<A.size();++i)printf("%d ",A[i]);
        if(min(Bans,Wans))puts("");
    }
    else if(b[n]){
        printf("%d\n",Wans);
        for(int i=0;i<B.size();++i)printf("%d ",B[i]);
        if(min(Bans,Wans))puts("");
    }
    else puts("-1");
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        solve();
    }
    return 0;
}

递归

树的遍历

一个二叉树，树中每个节点的权值互不相同。
现在给出它的后序遍历和中序遍历，请你输出它的层序遍历。

输入格式
第一行包含整数 N，表示二叉树的节点数。
第二行包含 N个整数，表示二叉树的后序遍历。
第三行包含 N个整数，表示二叉树的中序遍历。

输出格式
输出一行 N
个整数，表示二叉树的层序遍历。

数据范围
1≤N≤30,
官方并未给出各节点权值的取值范围，为方便起见，在本网站范围取1∼N。

输入样例：

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

输出样例：

4 1 6 3 5 7 2

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>

using namespace std;

const int N=110;
int n,a[N],b[N],p[N];
int l[N],r[N];

int build(int al,int ar,int bl,int br,int d){
    if(al>ar) return 0;
    int val=a[ar];
    int k=p[val];
    l[val]=build(al,al+k-1-bl,bl,k-1,d+1);
    r[val]=build(al+k-bl,ar-1,k+1,br,d+1);
    return val;
}
void bfs(){
    queue<int>q;
    q.push(a[n]);
    while (q.size()){
        int t = q.front();
        q.pop();
        cout<<t<<' ';
        if(l[t])q.push(l[t]);
        if(r[t])q.push(r[t]);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
    for(int i=1;i<=n;++i)scanf("%d",&b[i]),p[b[i]]=i;
    build(1,n,1,n,1);
    bfs();
    
    return 0;
}

约数

约数之和

假设现在有两个自然数 A和 B，S是 A^B的所有约数之和。
请你求出 Smod9901的值是多少。

输入格式
在一行中输入用空格隔开的两个整数 A和 B。

输出格式
输出一个整数，代表 Smod9901的值。

数据范围
0≤A,B≤5×10^7
输入样例：

2 3

输出样例：

注意: A和 B不会同时为 0。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

typedef long long LL;
const int mod=9901;
int a,b;

int qmi(int a,int k){
    a%=mod;
    int res=1;
    while(k){
        if(k&1)res=(LL)res*a%mod;
        a=(LL)a*a%mod;
        k>>=1;
    }
    return res;
}
int sum(int p,int k){
    if(k==1)return 1;
    if(k&1)return ((LL)sum(p,k-1)*p+1)%mod;
    return (LL)(1+qmi(p,k/2))*sum(p,k/2)%mod;
}
int main(){
    scanf("%d%d",&a,&b);
    LL res=1;
    for(int i=2;i*i<=a;++i){
        if(a%i==0){
            int s=0;
            while(a%i==0)++s,a/=i;
            res=res*sum(i,s*b+1)%mod;
        }
    }
    if(a>1)res=res*sum(a,b+1)%mod;
    if(a==0)res=0;
    printf("%lld\n",res);
    return 0;
}

并查集

亲戚

或许你并不知道，你的某个朋友是你的亲戚。
他可能是你的曾祖父的外公的女婿的外甥女的表姐的孙子。
如果能得到完整的家谱，判断两个人是否是亲戚应该是可行的，但如果两个人的最近公共祖先与他们相隔好几代，使得家谱十分庞大，那么检验亲戚关系实非人力所能及。
在这种情况下，最好的帮手就是计算机。
为了将问题简化，你将得到一些亲戚关系的信息，如Marry和Tom是亲戚，Tom和Ben是亲戚，等等。
从这些信息中，你可以推出Marry和Ben是亲戚。
请写一个程序，对于我们的关于亲戚关系的提问，以最快的速度给出答案。

输入格式
输入由两部分组成。
第一部分以 N,M 开始。N 为问题涉及的人的个数。这些人的编号为 1,2,3,…,N。下面有 M 行，每行有两个数 ai,bi，表示已知 ai 和 bi 是亲戚。
第二部分以 Q 开始。以下 Q 行有 Q 个询问，每行为 ci,di，表示询问 ci 和 di是否为亲戚。

输出格式
对于每个询问 ci,di，输出一行：若 ci和 di为亲戚，则输出“Yes”，否则输出“No”。

数据范围
1≤N≤20000,1≤M≤10⁶,1≤Q≤10⁶
输入样例：

输出样例：

Yes
No
Yes

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=2e4+10;
int n,m,q;
int fa[N];

int find(int x){
    if(x==fa[x])return x;
    return fa[x]=find(fa[x]);
}
void merge(int a,int b){
    int pa=find(a),pb=find(b);
    if(pa>pb)swap(pa,pb);
    if(pa==pb)return ;
    fa[pb]=pa;
}
void init(){
    for(int i=1;i<N;++i)fa[i]=i;
}
int main(){
    init();
    scanf("%d%d",&n,&m);
    while(m--){
        int a,b;
        scanf("%d%d",&a,&b);
        merge(a,b);
    }
    scanf("%d",&q);
    while(q--){
        int a,b;
        scanf("%d%d",&a,&b);
        if(find(a)==find(b))puts("Yes");
        else puts("No");
    }
    return 0;
}

合并集合

一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。

现在要进行 m个操作，操作共有两种：

M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作;
Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中；

输入格式
第一行输入整数 n 和 m。
接下来 m行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式
对于每个询问指令 Q a b，都要输出一个结果，如果 a和 b在同一集合内，则输出 Yes，否则输出 No。
每个结果占一行。

数据范围
1≤n,m≤10⁵
输入样例：

输出样例：

Yes
No
Yes

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=1e5+10;
int n,m;
int fa[N];

int find(int x){
    if(x==fa[x])return x;
    return fa[x]=find(fa[x]);
}
void merge(int a,int b){
    int pa=find(a),pb=find(b);
    if(pa>pb)swap(pa,pb);
    if(pa==pb)return;
    fa[pb]=pa;
}
void init(){
    for(int i=1;i<N;++i)fa[i]=i;
}
int main(){
    init();
    scanf("%d%d",&n,&m);
    while(m--){
        char op[2];
        int a,b;
        scanf("%s%d%d",op,&a,&b);
        if(op[0]=='M'){
            merge(a,b);
        }
        else if(op[0]=='Q'){
            if(find(a)==find(b))puts("Yes");
            else puts("No");
        }
    }
    return 0;
}

连通块中点的数量

给定一个包含 n 个点（编号为 1∼n）的无向图，初始时图中没有边。
现在要进行 m 个操作，操作共有三种：

C a b，在点 a 和点 b 之间连一条边，a 和 b 可能相等；
Q1 a b，询问点 a 和点 b 是否在同一个连通块中，a 和 b 可能相等；
Q2 a，询问点 a 所在连通块中点的数量；

输入格式
第一行输入整数 n 和 m。
接下来 m 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式
对于每个询问指令 Q1 a b，如果 a 和 b 在同一个连通块中，则输出 Yes，否则输出 No。
对于每个询问指令 Q2 a，输出一个整数表示点 a 所在连通块中点的数量
每个结果占一行。

数据范围
1≤n,m≤10⁵
输入样例：

输出样例：

Yes
2
3

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=1e5+10;
int n,m;
int fa[N],sz[N];

int find(int x){
    if(x==fa[x])return x;
    return fa[x]=find(fa[x]);
}
void merge(int a,int b){
    int pa=find(a),pb=find(b);
    if(pa>pb)swap(pa,pb);
    if(pa==pb)return;
    fa[pb]=pa;
    sz[pa]+=sz[pb];
}
void init(){
    for(int i=0;i<N;++i)fa[i]=i,sz[i]=1;
}
int main(){
    init();
    scanf("%d%d",&n,&m);
    while(m--){
        char op[3];
        int a,b;
        scanf("%s",op);
        if(op[0]=='C'){
            scanf("%d%d",&a,&b);
            merge(a,b);
        }
        else if(op[0]=='Q'&&op[1]=='1'){
            scanf("%d%d",&a,&b);
            if(find(a)==find(b))puts("Yes");
            else puts("No");
        }
        else if(op[0]=='Q'&&op[1]=='2'){
            scanf("%d",&a);
            printf("%d\n",sz[find(a)]);
        }
    }
    return 0;
}

银河英雄传说

有一个划分为 N 列的星际战场，各列依次编号为 1,2,…,N。
有 N 艘战舰，也依次编号为 1,2,…,N，其中第 i 号战舰处于第 i 列。

有 T条指令，每条指令格式为以下两种之一：

M i j，表示让第 i 号战舰所在列的全部战舰保持原有顺序，接在第 j 号战舰所在列的尾部。
C i j，表示询问第 i 号战舰与第 j 号战舰当前是否处于同一列中，如果在同一列中，它们之间间隔了多少艘舰。

现在需要你编写一个程序，处理一系列的指令。

输入格式
第一行包含整数 T，表示共有 T 条指令。
接下来 T 行，每行一个指令，指令有两种形式：M i j 或 C i j。
其中 M 和 C 为大写字母表示指令类型，i 和 j 为整数，表示指令涉及的战舰编号。

输出格式
你的程序应当依次对输入的每一条指令进行分析和处理：
如果是 M i j 形式，则表示舰队排列发生了变化，你的程序要注意到这一点，但是不要输出任何信息；
如果是 C i j 形式，你的程序要输出一行，仅包含一个整数，表示在同一上，第 i 号战舰与第 j 号战舰之间布置的战舰数目，如果第 i 号战舰与第 j 号战舰当前不在同一列上，则输出 −1。

数据范围
N≤30000,T≤500000
输入样例：

输出样例：

-1
1

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N=3e4+10;
int q;
int fa[N],sz[N],depth[N];

int find(int x){
    if(x==fa[x])return x;
    int t=find(fa[x]);
    depth[x]+=depth[fa[x]];
    return fa[x]=t;
}
void merge(int a,int b){
    int pa=find(a),pb=find(b);
    if(pa==pb)return;
    depth[pa]=sz[pb];
    sz[pb]+=sz[pa];
    fa[pa]=pb;
}
void init(){
    for(int i=1;i<N;++i)fa[i]=i,sz[i]=1,depth[i]=0;
}
int main(){
    init();
    scanf("%d",&q);
    while(q--){
        char op[2];
        int a,b;
        scanf("%s%d%d",op,&a,&b);
        if(op[0]=='M'){
            merge(a,b);
        }
        else if(op[0]=='C'){
            int pa=find(a),pb=find(b);
            if(pa==pb)
                printf("%d\n",max(0,abs(depth[a]-depth[b])-1));
            else puts("-1");
        }
    }
    return 0;
}