蓝桥杯刷题总结-合集(持续更新)

最新推荐文章于 2024-07-14 19:56:17 发布
最新推荐文章于 2024-07-14 19:56:17 发布
阅读量946 收藏 24
点赞数 21
分类专栏： 程序员 文章标签： 蓝桥杯 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84023482/article/details/138438063
版权

const int N = 6;

char g[N][N],backup[N][N];

// 偏移量,用于遍历(x,y)的上下左右中

int dx[5] = {1,0,-1,0,0},dy[5] = {0,1,0,-1,0};

// 将(x,y)的上下左右摁一遍

void turn(int x,int y){

for(int i = 0;i < 5;i++){

int nx = x + dx[i],ny = y + dy[i];

if(nx < 0 || nx > 5 || ny < 0 || ny > 5) continue; // 外界不需要考虑

if(g[nx][ny] == ‘0’) g[nx][ny] = ‘1’;

else g[nx][ny] = ‘0’;

}

}

int main(){

int T;

cin >> T;

while(T–){

// 将图读入

for(int i = 0;i < 5;i++) cin >> g[i];

// 第一行一共5个按钮,每个按钮开或不开一共2种情况,2^5 = 32

int ans = 10;

for(int op = 0;op < 32;op++){

memcpy(backup,g,sizeof g); // 将 g的内容放入backup中备份

int step = 0; // 操作的步数

// 第一行所有情况

for(int i = 0;i < 5;i++){

// 当前对应了1就操作

if(op >> i & 1){

step++;

turn(0,i);

}

}

// 每一行的每一个开关开或不开其实是受上一行的开关影响的

for(int i = 0;i < 4;i++){

for(int j = 0;j < 5;j++){

// 当前是关的,那么下一行对应的必须操作一次,这个才能打开

if(g[i][j] == ‘0’){

step++;

turn(i+1,j);

}

}

}

// 最后一行是不能有关闭的,否则就是不能实现

bool dark = false;

for(int i = 0;i < 5;i++){

if(g[4][i] == ‘0’){

dark = true;

break;

}

}

if(!dark) ans = min(ans,step);

memcpy(g,backup,sizeof g); // 将 g的内容放入backup中备份

}

if(ans > 6) ans = -1;

cout << ans << endl;

}

return 0;

}

java

import java.util.*;

public class Main{

static Scanner in = new Scanner(System.in);

static int max = 5;

static char[][] g = new char[max][max];

static char[][] backup = new char[max][max];

static int[] dx = {1,0,-1,0,0},dy = {0,1,0,-1,0};

public static void main(String[] args){

int T = in.nextInt();

// T个测试样例

while(T-- > 0){

// 读入图

int res = 10;

for(int i = 0;i < 5;i++) g[i] = in.next().toCharArray();

// 要对图进行一次备份

for(int i = 0;i < 5;i++){

for(int j = 0;j < 5;j++) backup[i][j] = g[i][j];

}

// 第一行有5个格子,每个格子开或关有2种可能,一共2^5=32种,我们这里采用二进制来表示

for(int op = 0;op < 32;op++){

int step = 0;

// 先操作第一行

for(int i = 0;i < 5;i++){

// 当前位是1就进行一次操作

if((op >> i & 1) == 1){

turn(0,i);

step++;

}

}

// 通过上一行操作下一行

for(int i = 0;i < 4;i++){

for(int j = 0;j < 5;j++){

// 当前是灭的,那么下一行对应的就要开

if(g[i][j] == ‘0’){

turn(i+1,j);

step++;

}

}

}

// 判断最后一行有没有灭的

boolean dark = false;

for(int i = 0;i < 5;i++){

if(g[4][i] == ‘0’){

dark = true;

break;

}

}

// 全灭的话

if(!dark) res = Math.min(res,step);

// 对图进行还原

for(int i = 0;i < 5;i++){

for(int j = 0;j < 5;j++) g[i][j] = backup[i][j];

}

}

// 超过步数

if(res > 6) res = -1;

// 此时已经遍历了32种情况

System.out.println(res);

}

}

public static void turn(int x,int y){

for(int i = 0;i < 5;i++){

int nx = x + dx[i],ny = y + dy[i];

if(nx < 0 || nx >= 5 || ny < 0 || ny >= 5) continue; // 出界不需要考虑

if(g[nx][ny] == ‘0’) g[nx][ny] = ‘1’;

else g[nx][ny] = ‘0’;

}

}

}

翻硬币

按照之前的思考：

  1. 每个硬币只会_主动_被翻一次(因为旁边的翻动不是主动翻动)

  2. 翻动的顺序没有关系

对于此题：

​ 我们可以就从左到右枚举，当前对应位不一样，就翻转一下即可。

c/c++

#include <bits/stdc++.h>

using namespace std;

string a,b;

int ans = 0;

int main(){

cin >> a >> b;

int n = a.length();

for(int i = 0;i < n - 1;i++){

// 当前字符不相等,就要翻转,

// 翻转后一定相等,就不用判断了

// 但是只要翻转了,下一个字符就一定会改

if(a[i] != b[i]){

ans++;

if(a[i+1] == ‘*’) a[i+1] = ‘o’;

else a[i+1] = ‘*’;

}

}

cout << ans << endl;

}

Java

import java.util.*;

import java.io.*;

public class Main{

static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

static int N = 110;

static char[] begin = new char[N],end = new char[N];

public static void main(String[] args)throws Exception{

int ans = 0;

// 读入

String a = in.readLine();

String b = in.readLine();

begin = a.toCharArray();

end = b.toCharArray();

for(int i = 0;i < begin.length-1;i++){

if(begin[i] != end[i]){

if(begin[i+1] == ‘*’) begin[i+1] = ‘o’;

else begin[i+1] = ‘*’;

ans++;

}

}

in.close();

System.out.println(ans);

}

}

飞行员兄弟

C/C++

#include <bits/stdc++.h>

#define x first

#define y second

using namespace std;

typedef pair<int,int> PII;

const int N = 5;

char g[N][N],backup[N][N];

// 将二维映射成一维

int get(int x,int y){

return x*4 + y;

}

void turn_one(int x,int y){

if(g[x][y] == ‘-’) g[x][y] = ‘+’;

else g[x][y] = ‘-’;

}

// 将x行,y列的所有操作一遍

void turn_all(int x,int y){

for(int i = 0;i < 4;i++){

turn_one(i,y);

turn_one(x,i);

}

// 上面导致(x,y)改变了两次,抵消了

turn_one(x,y);

}

int main(){

// 读入图

for(int i = 0;i < 5;i++) cin >> g[i];

vector ans;

// 枚举所有的情况

for(int op = 0;op < 1 << 16;op++){

memcpy(backup,g,sizeof g); // 备份

// 这一种情况的操作

vector temp;

// 对每一个点继续操作

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

// 点是二维的,我们映射成一维好操作

if(op >> get(i,j) & 1){

temp.push_back({i,j}); // 将操作入队列

turn_all(i,j);

}

}

}

// 判断是否全开的

bool has_closed = false;

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

if(g[i][j] == ‘+’) has_closed = true;

}

}

// 全是开的

if(!has_closed){

// ans为空或者ans的操作步骤比temp多

if(ans.empty() || ans.size() > temp.size()) ans = temp;

}

memcpy(g,backup,sizeof g); // 还原

}

// 输出

cout << ans.size() << endl;

for(auto op : ans){

cout << op.x + 1 << " " << op.y+1 << endl;

}

return 0;

}

Java

import java.util.*;

public class Main{

static int N = 4;

static char[][] g = new char[N][N],backup = new char[N][N];

static Scanner in = new Scanner(System.in);

static List<int[]> ans = new ArrayList<>();

public static void main(String[] args){

// 把图给读进来

for(int i = 0;i < 4;i++) g[i] = in.next().toCharArray();

// 一共16个开关,全部枚举,2^16

for(int op = 0;op < (1 << 16);op++){

List<int[]> temp = new ArrayList<>();

// 备份图

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

backup[i][j] = g[i][j];

}

}

// 遍历每一个点

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

// 为1就是要操作

if(((op >> get(i,j)) & 1) == 1){

turn_all(i,j);

temp.add(new int[]{i,j});

}

}

}

// 此时遍历完了,看是否全打开了

boolean has_closed = false;

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

if(g[i][j] == ‘+’) has_closed = true;

}

}

// 没有关闭的

if(!has_closed){

if(ans.isEmpty() || ans.size() > temp.size() ) ans = temp;

}

// 复原

for(int i = 0;i < 4;i++){

for(int j = 0;j < 4;j++){

g[i][j] = backup[i][j];

}

}

}

System.out.println(ans.size());

for(int[] res : ans){

System.out.printf(“%d %d\n”,res[0]+1,res[1]+1);

}

}

public static int get(int x,int y){

return 4 * x + y;

}

public static void turn_all(int x,int y){

for(int i = 0;i < 4;i++){

turn_one(x,i);

turn_one(i,y);

}

turn_one(x,y);

}

public static void turn_one(int x,int y){

if(g[x][y] == ‘-’) g[x][y] = ‘+’;

else g[x][y] = ‘-’;

}

}

带分数

思路一：

  1. 将带分数形式化为 ： n = a + b / c

  2. 其中a、b、c 就是1~9的组合

  3. 再简化 就是 n * c = a * c + b

  4. 这样我们只要枚举所有的a、b、c

  5. 能够让上面的等式成立即可

  6. 如何枚举所有所有的a、b、c呢？

  7. 通过之前的递归实现排列型枚举、也是全排列即可

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 10;

int path[N];

bool st[N];

int n,ans = 0;

// 计算path[l,r]的位数和

int cala(int l,int r){

int sum = 0;

for(int i = l; i <= r;i++){

sum *= 10;

sum += path[i];

}

return sum;

}

void dfs(int u){

if(u == N){

// 此时path中存了1~9的全排列

for(int i = 1;i <= 7;i++){

for(int j = i+1;j <= 8;j++){

int a = cala(1,i);

int b = cala(i+1,j);

int c = cala(j+1,9);

if(n*c == a * c + b) ans++;

}

}

}

for(int i = 1;i < N;i++){

if(!st[i]){

st[i] = true;

path[u] = i;

dfs(u+1);

st[i] = false;

}

}

}

int main(){

cin >> n;

dfs(1);

cout << ans << endl;

return 0;

}

JAVA

import java.util.*;

public class Main{

static int N = 10;

static int[] path = new int[N]; // 用于储存全排列

static boolean[] st = new boolean[N];

static Scanner in = new Scanner(System.in);

static int n,ans = 0;

public static void main(String[] args){

n = in.nextInt();

dfs(1);

System.out.println(ans);

}

private static void dfs(int u){

// 此时path以及存好了全排列

if(u == N){

for(int i = 1;i <= 7;i++){

for(int j = i+1;j <= 8;j++){

int a = cala(1,i);

int b = cala(i+1,j);

int c = cala(j+1,9);

if(nc == ac + b) ans++;

}

}

}

for(int i = 1;i < N ;i++){

if(!st[i]){

path[u] = i;

st[i] = true;

dfs(u+1);

st[i] = false;

}

}

}

public static int cala(int l,int r){

int sum = 0;

for(int i = l;i <= r;i++){

sum *= 10;

sum += path[i];

}

return sum;

}

}

思路二：

  1. 根据上面可知 n * c = a * c + b

  2. 等式中三个位置数，知道其中两个即可

  3. 那么我们枚举a和c，就可以得到b

  4. 判断b是否符合要求、如果符合要求即可

c/c++

#include <bits/stdc++.h>

using namespace std;

const int N = 20;

bool st[N],backup[N];

int n,ans;

// 判断等式是否成立

bool check(int a,int c){

int b = nc - ac;

// a b c 都得是非0的

if(!a || !b || !c) return false;

// st表在递归中还要使用，使用备份表

memcpy(backup,st,sizeof st);

// 判断b的每一位有没有和a、c有重合的

while(b){

int x = b % 10;

b /= 10;

// 出现位0或者重复使用过

if(!x || backup[x]) return false;

backup[x] = true;

}

// 判断每一位是否都使用过了

for(int i = 1;i <= 9;i++){

if(!backup[i]) return false;

}

return true;

}

void dfs_c(int u,int a,int c){

if(u == 9) return;

if(check(a,c)) ans++;

for(int i = 1;i <=9;i++){

if(!st[i]){

st[i] = true;

dfs_c(u+1,a,c*10+i);

st[i] = false;

}

}

}

// 从第u位枚举，此时的a大小位a

void dfs_a(int u,int a){

// 第10位

if(u == 9) return;

// 剪枝,因为 n = a + b/c 所有a肯定小于n

if(a > n) return;

// 递归枚举c

if(a) dfs_c(u,a,0);

for(int i = 1;i <= 9;i++){

if(!st[i]){

st[i] = true;

dfs_a(u+1,a*10+i);

st[i] = false;

}

}

}

int main(){

cin >> n;

dfs_a(0,0);

cout << ans << endl;

return 0;

}

Java

import java.util.*;

public class Main{

static int N = 10;

static boolean[] st = new boolean[N]; // 每一位只能使用一次

static Scanner in = new Scanner(System.in);

static int n,ans = 0;

public static void main(String[] args){

n = in.nextInt();

// 从1开始搜索,此时a为0

dfs_a(1,0);

System.out.println(ans);

}

private static void dfs_a(int u,int a){

// 第十位

if(u == N) return;

// 剪枝,a不可能大于n

if(a > n) return;

// 递归遍历c

if(a > 0) dfs_c(u,a,0);

for(int i = 1;i < N;i++){

if(!st[i]){

st[i] = true;

// 递归a

dfs_a(u+1,a*10+i);

st[i] = false;

}

}

}

private static void dfs_c(int u,int a,int c){

if(u == N) return;

// 判断此时的ac是否满足条件

if(check(a,c)) ans++;

for(int i = 1;i < N;i++){

if(!st[i]){

st[i] = true;

// 递归c

dfs_c(u+1,a,c*10+i);

st[i] = false;

}

}

}

// 判断是否满足条件

private static boolean check(int a,int c){

int b = n * c - a * c;

// a b c 都是正数

if(b <= 0 || a <= 0 || c <= 0) return false;

// 判断是否有重复使用的数

boolean[] backup = new boolean[N];

// 使用备份来判断

for(int i = 1;i < N;i++) backup[i] = st[i];

while(b > 0){

int x = b %10;

b /= 10;

if(x == 0 || backup[x]) return false;

backup[x] = true;

}

// 判断1~9是否每一位都使用过

for(int i = 1;i < N;i++){

if(!backup[i]) return false;

}

return true;

}

}

2、二分

整数二分模板

数的范围

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n,q;

int a[N];

int main(){

cin >> n >> q;

for(int i = 0;i < n;i++) cin >> a[i];

while(q–){

int k;

cin >> k;

// 边界

int l = 0,r = n-1;

// 找到第一个大于等于k的数

while(l < r){

// 枚举范围内的中点

int mid = (l + r) >> 1;

if(a[mid] >= k) r = mid;

else l = mid + 1;

}

// 可以发现，从上面的循环跳出来的时候 l = r

// 如果二分的结果不为k，表示没有这个数，输出-1 -1 即可

if(a[l] != k){

cout << “-1 -1” << endl;

continue;

}

// 运行到这里就是能找到这个数

cout << l << " ";

l = 0,r = n-1;

while(l < r){

int mid = (l+r+1) >> 1;

if(a[mid] <= k) l = mid;

else r = mid - 1;

}

cout << l << endl;

}

return 0;

}

Java

机器人跳跃问题

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n;

int h[N];

bool check(int mid){

// 模拟，走一遍

for(int i = 1;i <= n;i++){

mid = 2 * mid - h[i];

// 因为h[i] < 1e5,当中途的能量大于1e5的时候，就能直接确认一定能通过

if(mid >= 1e5) return true;

else if(mid < 0) return false;

}

return true;

}

int main(){

scanf(“%d”,&n);

for(int i = 1; i<= n;i++) scanf(“%d”,&h[i]);

int l = 0 ,r = 100000;

// 二分初始值

while(l < r){

int mid = (l + r) >> 1;

if(check(mid)) r = mid;

else l = mid + 1;

}

cout << l << endl;

}

JAVA

分巧克力

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

typedef long long LL;

int h[N],w[N];

int n,k;

bool check(int mid){

LL res = 0;

for(int i = 0;i < n;i++){

res += (h[i] / mid) * (w[i] / mid);

// 满足条件

if(res >= k) return true;

}

return false;

}

int main(){

scanf(“%d%d”,&n,&k);

// 读入长、宽

for(int i = 0;i < n;i++) scanf(“%d%d”,&h[i],&w[i]);

int l = 1,r = 1e5;

// 二分边长

while(l < r){

int mid = (l + r + 1) >> 1;

if(check(mid)) l = mid;

else r = mid - 1;

}

printf(“%d\n”,l);

return 0;

}

数的三次方根

​ 这个就是浮点数二分问题

C/C++

#include <bits/stdc++.h>

using namespace std;

int main(){

double n;

cin >> n;

// 看题目 n的数据范围 -10000 ~ 10000

double l = -10000,r = 10000;

// 精度是 小数点后六位，我们精确的8位一般就没问题

while(r-l > 1e-8){

double mid = (l + r) / 2;

if(mid * mid * mid > n) r = mid;

else l = mid;

}

printf(“%lf”,l);

return 0;

}

四平方和

C\C++

暴力，能过一定的点，最终TLE

#include<bits/stdc++.h>

using namespace std;

int n;

int main(){

scanf(“%d”,&n);

for(int a = 0;a*a <= n;a++){

for(int b = a;aa+bb <= n;b++){

for(int c = b;aa+bb+c*c<=n;c++){

int t = n - aa - bb - c*c;

int d = sqrt(t);

if(d * d == t){

printf(“%d %d %d %d\n”,a,b,c,d);

return 0;

}

}

}

}

return 0;

}

哈希

数据太强了、hash也卡

STL的哈希表

#include<bits/stdc++.h>

using namespace std;

typedef pair<int,int> PII;

int n;

unordered_map<int,PII> m;

int main(){

scanf(“%d”,&n);

for(int c = 0;c * c <= n;c++){

for(int d = c;dd + cc <= n;d++){

int t = cc + dd;

if(m.count(t) == 0) m[t] = {c,d};

}

}

for(int a = 0; a*a <= n;a++){

for(int b = 0;bb +aa<= n;b++){

int sum = n - aa - bb;

if(m.count(sum)){

printf(“%d %d %d %d\n”,a,b,m[sum].first,m[sum].second);

return 0;

}

}

}

return 0;

}

手写哈希表可以过

#include<bits/stdc++.h>

using namespace std;

typedef pair<int,int> PII;

int n;

const int N = 5000010;

int C[N],D[N];

int main(){

scanf(“%d”,&n);

// 初始化为-1

memset(C,-1,sizeof C);

for(int c = 0;c * c <= n;c++){

for(int d = c;dd + cc <= n;d++){

int s = cc + dd;

if(C[s] == -1){

C[s] = c,D[s] = d;

}

}

}

for(int a = 0; a*a <= n;a++){

for(int b = 0;bb +aa<= n;b++){

int s = n - aa - bb;

if(C[s] != -1){

printf(“%d %d %d %d”,a,b,C[s],D[s]);

return 0;

}

}

}

return 0;

}

3、前缀和

前缀和公式推导

前缀和

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int a[N],s[N];

int n,m;

int main(){

scanf(“%d%d”,&n,&m);

for(int i = 1;i <= n;i++){

scanf(“%d”,&a[i]);

// 处理前缀和数组

s[i] = s[i-1] + a[i];

}

while(m–){

int l,r;

scanf(“%d%d”,&l,&r);

printf(“%d\n”,s[r] - s[l-1]);

}

return 0;

}

K倍区间

C/C++

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N];

LL sum[N],cnt[N];

int n,k;

int main(){

scanf(“%d%d”,&n,&k);

for(int i = 1;i <= n;i++){

scanf(“%d”,&a[i]);

sum[i] += sum[i-1] + a[i]; // 前缀和数组

}

LL ans = 0;

// 余数为i的个数

cnt[0] = 1;

for(int i = 1;i <= n;i++){ // 枚举右端点

ans += cnt[sum[i] % k];

cnt[sum[i]%k]++;

}

printf(“%lld”,ans);

}

二维前缀和公式推导

子矩阵的和

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int a[N][N],s[N][N];

int n,m,q;

int main(){

scanf(“%d%d%d”,&n,&m,&q);

for(int i = 1;i <= n;i++){

Kafka进阶篇知识点

image

Kafka高级篇知识点

image

44个Kafka知识点（基础+进阶+高级）解析如下

image

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

t(C,-1,sizeof C);

for(int c = 0;c * c <= n;c++){

for(int d = c;dd + cc <= n;d++){

int s = cc + dd;

if(C[s] == -1){

C[s] = c,D[s] = d;

}

}

}

for(int a = 0; a*a <= n;a++){

for(int b = 0;bb +aa<= n;b++){

int s = n - aa - bb;

if(C[s] != -1){

printf(“%d %d %d %d”,a,b,C[s],D[s]);

return 0;

}

}

}

return 0;

}

3、前缀和

前缀和公式推导

前缀和

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int a[N],s[N];

int n,m;

int main(){

scanf(“%d%d”,&n,&m);

for(int i = 1;i <= n;i++){

scanf(“%d”,&a[i]);

// 处理前缀和数组

s[i] = s[i-1] + a[i];

}

while(m–){

int l,r;

scanf(“%d%d”,&l,&r);

printf(“%d\n”,s[r] - s[l-1]);

}

return 0;

}

K倍区间

C/C++

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N];

LL sum[N],cnt[N];

int n,k;

int main(){

scanf(“%d%d”,&n,&k);

for(int i = 1;i <= n;i++){

scanf(“%d”,&a[i]);

sum[i] += sum[i-1] + a[i]; // 前缀和数组

}

LL ans = 0;

// 余数为i的个数

cnt[0] = 1;

for(int i = 1;i <= n;i++){ // 枚举右端点

ans += cnt[sum[i] % k];

cnt[sum[i]%k]++;

}

printf(“%lld”,ans);

}

二维前缀和公式推导

子矩阵的和

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int a[N][N],s[N][N];

int n,m,q;

int main(){

scanf(“%d%d%d”,&n,&m,&q);

for(int i = 1;i <= n;i++){

Kafka进阶篇知识点

[外链图片转存中…(img-6AkgBeZP-1714794216162)]

Kafka高级篇知识点

[外链图片转存中…(img-dLQ7Dtrf-1714794216163)]

44个Kafka知识点（基础+进阶+高级）解析如下

[外链图片转存中…(img-UjzlMeRB-1714794216163)]

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84023482
关注
  • 21
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯刷题真解析-小白到大师的进阶之路
06-03
《蓝桥杯刷题真解析-小白到大师的进阶之路》是一份旨在帮助参赛者逐步提升编程技能、深入理解算法与数据结构的资源集合。"蓝桥杯"是一项全国性的编程竞赛，对于计算机科学和技术专业学生以及热衷于编程的爱好者来说...
【蓝桥杯刷题】数据结构模块（持续更新）
2301_80255237的博客
04-04 512
【蓝桥杯刷题】数据结构模块
【蓝桥杯刷题】搜索模块之DFS（持续更新）
2301_80255237的博客
04-01 305
【蓝桥杯刷题】搜索模块之DFS
【蓝桥杯刷题】字符串模块之字符串（持续更新）
2301_80255237的博客
04-03 445
【蓝桥杯刷题】字符串模块之字符串
蓝桥杯刷题总结
寸铁的博客
06-30 220
蓝桥杯刷题总结
LanQiaoCup蓝桥杯刷题
04-30
这个名为"LanQiaoCup蓝桥杯刷题"的压缩包文件很可能是为参赛者准备的一系列练习题目和参考资料，帮助他们熟悉比赛的题型和提高解题技巧。 在"蓝桥杯"竞赛中，主要涉及的知识点涵盖了编程语言（如C++、Java、Python...
c++蓝桥杯刷题代码.zip
06-02
【标题】"c++蓝桥杯刷题代码.zip"指的是一个包含了C++编程语言的练习题目解决方案的压缩文件，主要用于准备“蓝桥杯”编程竞赛。这个标题暗示了该压缩包可能包含了一系列针对蓝桥杯比赛的算法题目，旨在帮助参赛者...
蓝桥杯-嵌入式-04-USART
02-29
在"蓝桥杯-嵌入式-04-USART"的主题中，我们主要探讨的是如何在嵌入式开发中使用和理解USART功能。 USART的工作原理： USART是一种半双工通信协议，支持单向或双向数据传输。它能在同一时刻进行发送和接收，但不能...
蓝桥杯-嵌入式-02-LED-KEY
02-28
"蓝桥杯-嵌入式-02-LED-KEY"这个主题，涉及到的是嵌入式开发的一个基础部分，即LED（Light Emitting Diode，发光二极管）和按键（KEY）的控制。 LED是电子设备中常见的指示器，用于显示设备状态或者用户界面反馈。...
iOS开发新手教程：Swift语言与Xcode工具链
2401_85639015的博客
07-05 1026
Swift是苹果公司于2014年发布的一种现代化编程语言，专为iOS、macOS、watchOS和tvOS开发设计。它结合了C和Objective-C的优点，支持安全性、性能和现代编程模式。Xcode是苹果公司为开发iOS、macOS、watchOS和tvOS应用提供的集成开发环境（IDE）。它包括编写代码、设计界面、编译、调试和发布应用的所有工具。// 自定义绘制代码本文详细介绍了iOS开发的基础知识，包括Swift语言基础、Xcode工具链的使用以及iOS应用开发的基本流程。
36. Adam 算法详解
qq_41238579的博客
07-10 944
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 53
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 178
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 58
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
【排序 - 堆排序】
2302_80393814的博客
07-10 454
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 164
【代码】代码随想录算法训练营第33天。
摩尔投票算法
qq_55846232的博客
07-14 155
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 131
手撕七大排序 （三）
蓝桥杯刷题Python
10-22
蓝桥杯是国内著名的计算机竞赛，每年都会举办省、市、校三个层次...同时，也可以参考一些蓝桥杯Python刷题资料，例如《Python语言程序设计》、《Python编程从入门到实践》等书籍，或者在网上搜索相关的Python刷题资源。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值