A:::::::::::::::::::::::::::::::::::m计划（双指针，滑动窗口，倍增）
小明是个鹅卵石收藏者，从小到大他一共收藏了 nn 块鹅卵石，编号分别为 1∼n，价值分别为 a1，a2，⋯,an。
这天他乘船准备去往蓝桥王国，然而天有不测风云，小明所在的海域下起了暴雨。
很快小明船上的积水越来越多，为了防止沉船，小明不得不选择若干块他收藏的鹅卵石丢弃。
小明制定了一套名为m计划的选择方案，其内容如下：
请你输出将被小明丢弃的鹅卵石的价值。
输入第 1 行包含两个正整数 n,m。
接下来一行包含 n 个正整 a1,a2,⋯,an，表示鹅卵石的价值。
1≤m≤n≤5×10的5次方，0≤ai≤10的9次方。
输出共 n−m+1 行，每行输出一个整数，第 i 行输出整数的含义为 ai,ai+1,⋯,ai+m−1 的最小值。
示例 1
输入
5 3
5 3 2 4 1
输出
2
2
1
#include <iostream>
using namespace std;
int n,m;
int a[500005];
struct node{
int xiabiao;
int min1;
};
node check1(int x,int y){
node ans1;
ans1.xiabiao=0;
ans1.min1=1000000;
for(int i=x;i<=y;i++){
if(a[i]<=ans1.min1){
ans1.min1=a[i];
ans1.xiabiao=i;
}
}
return ans1;
}
bool check2(int l,int r,int x){
return x>=l&&x<=r;
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
}
node mm=check1(1,m);
int l=2,r=m+1;
cout<<mm.min1<<endl;
while(r<=n){
if(check2(l,r,mm.xiabiao)){
if(mm.min1>=a[r]){
mm.min1=a[r];
mm.xiabiao=r;
}
}else{
mm=check1(l,r);
}
cout<<mm.min1<<endl;
r++;
l++;
}
return 0;
}
B:::::::::::::::::::::::::::::::::::长草（BFS）
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，
这四小块空地都将变为有草的小块。请告诉小明，k 个月后空地上哪些地方有草。
输入的第一行包含两个整数 n,m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
接下来包含一个整数 k。 其中，2≤n,m≤1000，1≤k≤1000。
输出 n 行，每行包含 mm 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
示例
输入
4 5
.g...
.....
..g..
.....
2
输出
gggg.
gggg.
ggggg
.ggg.
#include <iostream>
#include <queue>
using namespace std;
int n,m,k;
char a[1005][1005];
struct node{
int x,y;
int su;
node(int xx,int yy,int suu){
x=xx;
y=yy;
su=suu;
}
};
queue<node> h;
bool check(int x,int y){
return x>=1&&x<=n&&y>=1&&y<=m;
}
int f[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>a[i][j];
if(a[i][j]=='g'){
h.push(node(i,j,0));
}
}
}
cin>>k;
while(!h.empty()){
node j=h.front();
h.pop();
for(int i=0;i<4;i++){
int tx=j.x+f[i][0];
int ty=j.y+f[i][1];
if(check(tx,ty) && a[tx][ty]=='.' && j.su+1<=k){
a[tx][ty]='g';
h.push(node(tx,ty,j.su+1));
}
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cout<<a[i][j];
}
cout<<endl;
}
return 0;
}
C:::::::::::::::::::::::::::::::::::带分数（全排列）
100 可以表示为带分数的形式：100 = 3 + 69258 / 714
还可以表示为：100 = 82 + 3546 / 197
注意特征：带分数中，数字 1~9 分别出现且只出现一次（不包含 0 ）。
类似这样的带分数，100 有 11 种表示法。
从标准输入读入一个正整数 (N<1000×1000)。
程序输出该数字用数码 1~9 不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
示例
输入
100
输出
11
#include <iostream>
#include <algorithm>
using namespace std;
int n;
long long ans;
int a[9]={1,2,3,4,5,6,7,8,9};
int he(int l,int r){
int ans1=0;
for(int i=l;i<=r;i++){
ans1=ans1*10+a[i];
}
return ans1;
}
int main(){
cin>>n;
while(next_permutation(a,a+9)){
for(int i=0;i<7;i++){
for(int j=i+1;j<8;j++){
int a=he(0,i);
int b=he(i+1,j);
int c=he(j+1,8);
if(a*c+b==n*c){
ans++;
}
}
}
}
cout<<ans;
return 0;
}D:::::::::::::::::::::::::::::::::::合根植物（并查集）
w 星球的一个种植园，被分成 m×n 个小格子（东西方向 m 行，南北方向 n 列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
第一行，两个整数 m,n，用空格分开，表示格子的行数、列数（1≤m,n≤1000）。
接下来一行，一个整数 k (0≤k≤105 )，表示下面还有 k 行数据。
接下来 k 行，每行两个整数 a，b，表示编号为 a 的小格子和编号为 b 的小格子合根了。
格子的编号一行一行，从上到下，从左到右编号。
比如：5×4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20
输出植物数量。
示例
输入
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17
输出
5
样例说明
其合根情况参考下图：
#include <iostream>
#include <algorithm>
using namespace std;
int m,n,k;
int vis[1000005];
int fa[1000005];
int find(int x){
if(fa[x]==x) return x;
return fa[x]=find(fa[x]);
}
int ans;
void jiaru(int x,int y){
int tx=find(x);
int ty=find(y);
if(tx!=ty){
fa[tx]=ty;
}
}
int main(){
cin>>m>>n>>k;
for(int i=0;i<=n*m;i++){
fa[i]=i;
}
for(int i=0;i<k;i++){
int a,b;
cin>>a>>b;
jiaru(a,b);
}
for(int i=1;i<=n*m;i++){
vis[find(i)]=1;
}
for(int i=1;i<=n*m;i++){
if(vis[i]){
ans+=1;
}
}
cout<<ans;
return 0;
}E:::::::::::::::::::::::::::::::::::修建公路(最小生成树，并查集)
LL 城一共有 N 个小区。
小明是城市建设的规划者，他计划在城市修 M 条路，每修建一条路都要支付工人们相应的工钱（需要支付的工钱 = 路的长度）。
然而小明所拿到的经费并不够支付修建 M 条路的工钱，于是迫于无奈，他只能将计划改变为修建若干条路，使得 N 个小区之间两两联通。
小明希望尽量剩下更多的经费投入到别的项目中，因此请你通过程序帮他计算出完成计划所需的最低开销。
输入第一行包含三个正整数N,M。
第 2 到 M+1 行每行包含三个正整数 u,v,w，表示 u↔v 之间存在一条距离为 w 的路。
输出占一行，包含一个整数，表示完成计划所需的最低开销。
若无法完成计划，则输出 -1−1。
示例 1
输入
5 6
1 2 2
1 3 7
1 4 6
2 3 1
3 4 3
3 5 2
输出
8
#include <iostream>
#include <algorithm>
using namespace std;
int n,m;
int fa[100005];
int find(int x){
if(fa[x]==x) return x;
return fa[x]=find(fa[x]);
}
struct node{
int qi,zhong;
int juli;
};
bool cmp(node x,node y){
return x.juli<y.juli;
}
long long ans;
node g[300005];
int main(){
cin>>n>>m; //n个城市，m个规划
for(int i=1;i<=n;i++){
fa[i]=i;
}
for(int i=1;i<=m;i++){
cin>>g[i].qi>>g[i].zhong>>g[i].juli;
}
sort(g+1,g+m+1,cmp);
for(int i=1;i<=m;i++){
int tx=find(g[i].qi);
int ty=find(g[i].zhong);
if(tx!=ty){
ans+=g[i].juli;
fa[tx]=ty;
}
}
int w=find(1);
for(int i=1;i<=n;i++){
if(w!=find(i)){
cout<<-1;
return 0;
}
}
cout<<ans;
return 0;
}
F:::::::::::::::::::::::::::::::::::小明的背包2（完全背包）
小明有一个容量为 V 的背包。
这天他去商场购物，商场一共有 N 种物品，第 ii 种物品的体积为 wi，价值为 vi，每种物品都有无限多个。
小明想知道在购买的物品总体积不超过 V 的情况下所能获得的最大价值为多少，请你帮他算算。
输入第 1 行包含两个正整数 N,V，表示商场物品的数量和小明的背包容量。
第 2∼N+1 行包含 2 个正整数w,v，表示物品的体积和价值。
输出一行整数表示小明所能获得的最大价值。
示例 1
输入
5 20
1 6
2 5
3 8
5 15
3 3
输出
120
#include <iostream>
#include <cmath>
using namespace std;
int n,v;
int wi[1005];
int vi[1005];
int dp[1005][1005];
int main(){
cin>>n>>v;
for(int i=1;i<=n;i++){
cin>>wi[i]>>vi[i]; //体积和价值
}
for(int i=1;i<=n;i++){
for(int j=1;j<=v;j++){
dp[i][j]=dp[i-1][j];
if(j>=wi[i]){
dp[i][j]=max(dp[i-1][j],dp[i][j-wi[i]]+vi[i]);
}
}
}
cout<<dp[n][v];
return 0;
}
G:::::::::::::::::::::::::::::::::::作物杂交（搜索）
作物杂交是作物栽培中重要的一步。已知有 N 种作物 (编号 1 至 N)，第 i 种作物从播种到成熟的时间为 Ti。作物之间两两可以进行杂交，杂交时间取两种中时间较长的一方。如作物 A 种植时间为 5 天，作物 B 种植时间为 7 天，则 AB 杂交花费的时间为 7 天。作物杂交会产生固定的作物，新产生的作物仍然属于 N 种作物中的一种。
初始时，拥有其中 M 种作物的种子 (数量无限，可以支持多次杂交)。同时可以进行多个杂交过程。求问对于给定的目标种子，最少需要多少天能够得到。
如存在 4 种作物 ABCD，各自的成熟时间为 5 天、7 天、3 天、8 天。初始拥有 AB 两种作物的种子，目标种子为 D，已知杂交情况为 A × B → C，A × C → D。则最短的杂交过程为：
第 1 天到第 7 天 (作物 B 的时间)，A × B → C。
第 8 天到第 12 天 (作物 A 的时间)，A × C → D。
花费 12 天得到作物 D 的种子。
输入的第 1 行包含 4 个整数 N,M,K,T，NN 表示作物种类总数 (编号 1 至 N)，MM 表示初始拥有的作物种子类型数量，KK 表示可以杂交的方案数，TT 表示目标种子的编号。
第 2 行包含 N 个整数，其中第 ii 个整数表示第 ii 种作物的种植时间 Ti (1≤Ti≤100)。
第 3 行包含 M 个整数，分别表示已拥有的种子类型 (1≤Kj≤M)，Kj 两两不同。
第 4 至 K + 3 行，每行包含 3 个整数 A,B,C，表示第 A 类作物和第 B 类作物杂交可以获得第 C 类作物的种子。
其中，1≤N≤2000,2≤M≤N,1≤K≤105,1≤T≤N, 保证目标种子一定可以通过杂交得到。
输出一个整数，表示得到目标种子的最短杂交时间。
示例
输入
6 2 4 6
5 3 4 6 4 9
1 2
1 2 3
1 3 4
2 3 5
4 5 6
输出
16
样例说明
第 1 天至第 5 天，将编号 1 与编号 2 的作物杂交，得到编号 3 的作物种子。
第 6 天至第 10 天，将编号 1 与编号 3 的作物杂交，得到编号 4 的作物种子。
第 6 天至第 9 天，将编号 2 与编号 3 的作物杂交，得到编号 5 的作物种子。
第 11 天至第 16 天，将编号 4 与编号 5 的作物杂交，得到编号 6 的作物种子。
总共花费 16 天。
| 语言 | 最大运行时间 | 最大运行内存 |
|---|---|---|
| C++ | 2s | 256M |
| C | 2s | 256M |
| Java | 3s | 256M |
| Python3 | 10s | 256M |
#include <iostream>
#include <vector>
using namespace std;
const int maxn=0x3f3f3f3f;
int tim[2010];
int dp[2010];
vector<pair<int, int> > zajiao[2010];
int f(int n){
if (dp[n]!=maxn) return dp[n];
for (int i=0;i<zajiao[n].size();++i){
int a=zajiao[n][i].first,b=zajiao[n][i].second;
int tmp = max(f(a), f(b))+max(tim[a],tim[b]);
dp[n]=min(dp[n],tmp);
}
return dp[n];
}
int main(){
for (int i=0;i<2010;i++){
dp[i]=maxn;
}
int n,m,k,t;
cin>>n>>m>>k>>t;
for (int i=1;i<=n;++i){
cin>>tim[i];
}
for (int i=1;i<=m;++i){
int j;
cin>>j;
dp[j]=0;
}
for (int i=1;i<=k;++i){
int a,b,c;
cin>>a>>b>>c;
zajiao[c].push_back(make_pair(a, b));
}
f(t);
cout<<dp[t]<<endl;
return 0;
}H:::::::::::::::::::::::::::::::::::序列求和(DFS，唯一分解定理)
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
学习了约数后，小明对于约数很好奇，他发现，给定一个正整数 tt，总是可以找到含有 tt 个约数的整数。小明对于含有 tt 个约数的最小数非常感兴趣，并把它定义为 S_tSt 。
例如S1=1,S2=2,S3=4,S4=6，⋅⋅⋅ 。
现在小明想知道，前 60 个 Si 的和是多少？即 S1+S2+⋅⋅⋅+S60 是多少？
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<long long> m;
int su[100000];
bool check(long long x){
if(x==1){
return false;
}
if(x==2){
return true;
}
for(int i=2;i*i<=x;i++){
if(x%i==0){
return false;
}
}
return true;
}
long long pow1(long long a,long long b){
long long ans=1;
while(b){
if(b&1) ans=ans*a;
b/=2;
a*=a;
}
return ans;
}
long long ans;
long long res1=1e18;
long long dfs(long long x,vector<long long>g)
{
if(check(x)||x==1)return pow1(2,x-1);
for(long long i=2;i*i<=x;i++)
{
if(x%i==0)
{
long long t=x/i;
g.push_back(i);
vector<long long>tmp=g;
tmp.push_back(t);
sort(tmp.begin(),tmp.end(),greater<long long>());
long long s=1;
for(int j=0;j<tmp.size();j++)
s*=pow1(su[j],tmp[j]-1);
res1=min(res1,s);
dfs(t,g);
g.pop_back();
}
}
return res1;
}
int main(){
int cc=0;
for(int i=2;i<=100000;i++){
if(check(i)){
su[cc]=i;
cc++;
}
}
ans=1+2+4+6;
for(int i=5;i<=60;i++){
res1=1e18;
m.clear();
long long ans1=dfs(i,m);
ans+=ans1;
}
cout<<ans;
return 0;
}I:::::::::::::::::::::::::::::::::::青蛙跳杯子（BFS）
XX 星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。
XX 星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。
如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。
∗WWWBBB
其中，W 字母表示白色青蛙，B 表示黑色青蛙，*∗ 表示空杯子。
X 星的青蛙很有些癖好，它们只做 3 个动作之一：
跳到相邻的空杯子里。
隔着 1 只其它的青蛙（随便什么颜色）跳到空杯子里。
隔着 2 只其它的青蛙（随便什么颜色）跳到空杯子里。
对于上图的局面，只要 1 步，就可跳成下图局面：
WWW∗BBB
本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。
输入为 2 行，2 个串，表示初始局面和目标局面。我们约定，输入的串的长度不超过 15。
输出要求为一个整数，表示至少需要多少步的青蛙跳。
示例
输入
*WWBB
WWBB*
输出
2
#include <iostream>
#include <queue>
#include <string>
#include <map>
using namespace std;
string a,b;
struct node{
string a;
int bu;
int x;
node(string aa,int buu,int xu){
a=aa;
bu=buu;
x=xu;
}
};
string jiaohuan(string a,int x,int y){
char m=a[x];
a[x]=a[y];
a[y]=m;
return a;
}
map<string,bool> kk;
queue<node> q;
bool check(int x){
return x>=0 && x<a.size();
}
int f[6]={1,-1,2,-2,3,-3};
int main(){
cin>>a>>b;
int c=0;
for(int i=0;i<a.size();i++){
if(a[i]=='*'){
c=i;
}
}
kk[a]=1;
q.push(node(a,0,c));
while(!q.empty()){
node t=q.front();
q.pop();
if(t.a==b){
cout<<t.bu;
break;
}
for(int i=0;i<6;i++){
int tx=t.x+f[i];
string xx=jiaohuan(t.a,t.x,tx);
if(check(tx) && !kk[xx]){
kk[xx]=1;
q.push(node(xx,t.bu+1,tx));
}
}
}
return 0;
}
J:::::::::::::::::::::::::::::::::::剪格子（DFS）
如下图所示，3 x 3 的格子中填写了一些整数。
我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是 60。
本题的要求就是请你编程判定：对给定的 m×n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割，则输出 0。
输入描述
程序先读入两个整数 m,n 用空格分割 (m,n<10)，表示表格的宽度和高度。
接下来是 n 行，每行 m 个正整数，用空格分开。每个整数不大于 104。
在所有解中，包含左上角的分割区可能包含的最小的格子数目。
示例
输入
3 3
10 1 52
20 30 1
1 2 3
输出
3
#include <iostream>
using namespace std;
int a[15][15];
int n,m;
int sum;
int he;
int ans=1e9;
bool vis[15][15];
int aa[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
bool check(int x,int y){
return x>=0&&x<=n&&y>=0&&y<=m;
}
void dfs(int x,int y,int g){
if(g>=ans){
return;
}
if(he==sum/2){
ans=min(ans,g);
}
for(int i=0;i<4;i++){
int tx=x+aa[i][0];
int ty=y+aa[i][1];
if(check(tx,ty) && !vis[tx][ty]){
vis[tx][ty]=1;
he+=a[tx][ty];
dfs(tx,ty,g+1);
he-=a[tx][ty];
vis[tx][ty]=0;
}
}
}
int main(){
cin>>m>>n;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
int x=0;
cin>>x;
a[i][j]=x;
sum+=x;
}
}
if(sum%2==1){
cout<<0;
return 0;
}
vis[1][1]=1;
he=a[1][1];
dfs(1,1,1);
cout<<ans;
return 0;
}
目录前言： 一、ASC分析代码实现二、 卡片分析代码实现三、 直线分析代码实现四、货物摆放分析代码实现小结：前言： 在刷题的过程中，发现蓝桥杯的题目和力扣的差别很大。让人有一种不一样的感觉，蓝桥杯题目偏向对于实际问题用编程去的解决，而力扣给人感觉很锻炼自己的编程思维，逻辑能力。两者结合去刷，相信会有不一样的收获。 一、ASC 已知大写字母A的ASCII码为65，请问大写字母L的ASCII码是多少？分析 这道题目看上去很简单，我们需确定自己计算的准确，所以我建议用编程去解决。代码实现publicclassTest8{publicstaticvoidmain(String[]args){Sy
?作者主页：静Yu?简介：CSDN全栈优质创作者、华为云享专家、阿里云社区博客专家，前端知识交流社区创建者?社区地址：前端知识交流社区?博主的个人博客：静Yu的个人博客?博主的个人笔记本：前端面试题个人笔记本只记录前端领域的面试题目，项目总结，面试技巧等等。接下来会更新蓝桥杯官方系统基础练习的VIP试题，依然包括解题思路，源代码等等。问题描述：给定当前的时间，请用英文的读法将它读出来。时间用时h和分m表示，在英文的读法中，读一个时间的方法是： 如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“threeo’clock”。 如果m不为0，则将时读出来，然后将分读出来，如5
十四届蓝桥青少组模拟赛Python-20221108T1.二进制位数十进制整数2在十进制中是1位数，在二进制中对应10，是2位数。十进制整数22在十进制中是2位数，在二进制中对应10110，是5位数。请问十进制整数2022在二进制中是几位数？print(len(bin(2022))-2)#运行结果：11T2.晨跑小蓝每周六、周日都晨跑，每月的1、11、21、31日也晨跑。其它时间不晨跑。已知2022年1月1日是周六，请问小蓝整个2022年晨跑多少天？#样例代码1ls=[0,31,28,31,30,31,30,31,31,30,31,30,31]ans=0k=6foriinrange(1,13)
本文代码使用HAL库。文章目录前言一、MCP4017的重要特性二、MCP4017计算RBW阻值三、MCP4017地址四、MCP4017读写函数五、CubeMX创建工程（利用ADC测量MCP4017电压）、对应代码：总结前言一、MCP4017的重要特性蓝桥杯板子上的是MCP4017T-104ELT，如图1。MCP4017是一个可编程电阻，通过写入的数值可以改变电阻的大小。重点在于6引脚（W），5引脚（B&#
目录一、原理部分1、什么是串行通信（1）并行通信与串行通信（2）串行通信的制式（3）串行通信的主要方式 2、配置串口（1）SCON和PCON：串行口1的控制寄存器（2）SBUF：串行口数据缓冲寄存器 （3）AUXR：辅助寄存器编辑（4）ES、PS：与串行口1中断相关的寄存器（5）波特率设置 3、串口框架编写二、程序案例一、原理部分1、什么是串行通信（1）并行通信与串行通信微控制器与外部设备的数据通信，根据连线结构和传送方式的不同，可以分为两种：并行通信和串行通信。并行通信：数据的各位同时发送与接收，每个数据位使用一条导线，这种方式传输快，但是需要多条导线进行信号传输。串行通信：数据一位一
问题描述小蓝负责一个公司的考勤系统,他每天都需要根据员工刷卡的情况来确定每个员工是否到岗。当员工刷卡时,会在后台留下一条记录,包括刷卡的时间和员工编号,只要在一天中员工刷过一次卡,就认为他到岗了。现在小蓝导出了一天中所有员工的刷卡记录,请将所有到岗员工的员工编号列出。输入格式输入的第一行包含一个正整数n,表示一天中所有员工的刷卡记录的条数。接下来n行,每行包含一条刷卡记录,每条刷卡记录的格式为:HH:MM:SSID其中HH:MM:SS表示刷卡时间,HH为一个0到23之间的两位十进制整数(可能含前导0)表示时,MM为一个0到59之间的两位十进制整数(可能含前导0)表示分,SS为一个0到59之间的
目录1 例题1.1 卡片换位1.2 人物相关性分析2 字符串的读取2.1 综述2.2 scanf2.3 getline/getchar/get2.4 注意2.5 说明3 C语言中字符串有关问题3.1 常用函数3.2 使用实例3.3 附一些函数先看例题1 例题1.1 卡片换位问题描述你玩过华容道的游戏吗？这是个类似的，但更简单的游戏。看下面3x2的格子在其中放5张牌，其中A代表关羽，B代表张飞，*代表士兵。还有一个格子是空着的。你可以把一张牌移动到相邻的空格中去(对角不算相邻)。游戏的目标是：关羽和张飞交换位置，其它的牌随便在哪里都可以。输入格式：输入两行6个字符表示当前的局面输出格式：一个整
原题链接https://www.dotcpp.com/oj/problem3162.html想直接看题解的，跳转到第三次尝试即可。已AC。解析：（1）首先大家要知道什么叫互质：以及它们的性质：欧拉函数在数论中，对正整数n，欧拉函数φ(n)是小于或等于n的正整数中与n互质的数的数目。此函数以其首名研究者欧拉命名，它又称为φ函数（由高斯所命名）或是欧拉总计函数（totientfunction，由西尔维斯特所命名）。例如φ(8)=4，因为1,3,5,7均和8互质。也可以从简化剩余系的角度来解释，简化剩余系(reducedresiduesystem)也称既约剩余系或缩系，是m的完全剩余系中与m互素的数
蓝桥杯第十四届蓝桥杯模拟赛第三期考场应对攻略（C/C++）真题可以去此处寻找https://blog.csdn.net/weixin_46239370/article/details/105464885?spm=1001.2014.3001.5506考前准备考前五分钟，开十个源文件，并把头文件等必须写的部分写出来，写完的程序一定要有顺序地保留万能头可以尝试开一下#include试题1：问题描述请找到一个大于2022的最小数，这个数转换成十六进制之后，所有的数位（不含前导0）都为字母（A到F）。请将这个数的十进制形式作为答案提交。答案提交这是一道结果填空的题，你只需要算出结果后提交即可。本题的结
大家好，我是普通小明，初入学习博客，一起加油！ 首先，感谢小蓝刷题对我的鼓励，我也希望加入学习算法这个大家庭。第一篇文章，有些不完美，还请多多指教。目录（好像我并不会用锚点T-T）省赛心得蜂巢题解-思路点拨蜂巢题解-AC代码蜂巢题解-刷题总结未来展望省赛心得遗憾落幕十三届蓝桥PyB省赛，破灭了大一自学算法拿下国奖的传奇神话究其原因1、对算法过多理论而缺少实践，缺少刷题量。2、对算法的理解不够全面。3、对数论算法有所欠缺。立志1、一年时间完成蓝桥刷题系统过半题量。2、全面掌握各种算法，并且形成模板记忆。3、多看数学难题，提升思维转换能力。一、蜂巢题解-思路点拨个人主页有另一个更简单的解法读完题没