蓝桥杯刷题-第一章 递归与递推

最新推荐文章于 2024-11-09 18:10:37 发布
最新推荐文章于 2024-11-09 18:10:37 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： # 蓝桥杯 文章标签： 蓝桥杯 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Destiny_159/article/details/121825948
版权

蓝桥杯刷题-第一章 递归与递推

BaseOn ： https://www.acwing.com

1、递归与递推

递归实现指数型枚举

java

import java.util.*;

public class Main{
    static Scanner in = new Scanner(System.in);		// 输入
    // 看题目范围 n是1到15，我们稍微把数组开大一点点、防止数组越界。
    static int max = 20,n;							
    // 判断每一位是否被用过
    static boolean[] st = new boolean[max];
    public static void main(String[] args){
        n = in.nextInt();
        dfs(0);
    }
    // dfs(深度优先搜索)
    private static void dfs(int u){
        // 搜索到最后一位
        if(u == n){
            // 打印输出
            for(int i = 0;i < n;i++){
                if(st[i]) System.out.printf("%d ",i+1);
            }
            System.out.println();
            return;
        }
        // 要第u位
        st[u] = true;
        dfs(u+1);
        // 不要第u位
        st[u] = false;
        dfs(u+1);
    }
}

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 20;

bool st[N];

int n;

void dfs(int u){
    // 递归到了叶子节点
    if(u == n){
        for(int i = 0;i < n;i++){
            if(st[i]) cout << i + 1 << " ";
        }
        cout << endl;   // 换行
        return;
    }
    // 选
    st[u] = true;
    dfs(u+1);
    
    // 不选
    st[u] = false;
    dfs(u+1);
}

int main(){
    cin >> n;
    dfs(0);
    return 0;
}

在这里插入图片描述

递归实现排列型枚举

Java

import java.util.*;
import java.io.*;
public class Main {
    static Scanner in = new Scanner(System.in);
    static int max = 10, n;
    static int[] path = new int[max];       // 存储路径
    static boolean[] st = new boolean[max]; // 记录每个数字是否被使用了
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args)throws Exception{
        n = in.nextInt();
        dfs(0);
        out.flush();
    }
    private static void dfs(int u) throws Exception{
        if(u == n){
            for(int i = 0;i < n;i++) out.write(path[i] + " ");	// 快速写出
            out.write("\n");       // 换行
            return;
        }
        for(int i = 0;i < n;i++){
            if(!st[i]){
                st[i] = true;
                path[u] = i+1;
                dfs(u+1);
                st[i] = false;
                path[u] = 0;
            }
        }
    }
}

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 10;

int path[N];
bool st[N];
int n;

void dfs(int u){
    if(u == n){
        for(int i = 0;i < n;i++) cout << path[i] << " ";
        cout << endl;
        return;
    }
    for(int i = 0;i < n;i++){
        if(!st[i]){
            st[i] = true;
            path[u] = i+1;
            dfs(u+1);
            st[i] = false;
        }
    }
}

int main(){
    cin >> n;
    dfs(0);
    return 0;
}

递归实现组合型枚举

Java

import java.util.*;
public class Main{
    static Scanner in = new Scanner(System.in);
    static int max = 30,n,m;
    static int[] path = new int[max];
    public static void main(String[] args){
        n = in.nextInt();
        m = in.nextInt();
        dfs(0);
        return;
    }
    public static void dfs(int u){
        if(u == m){
            for(int i = 0;i < m;i++) System.out.printf("%d ",path[i]);
            System.out.println();
            return;
        }
        for(int i = 1;i <= n;i++){
            if(u == 0) path[u] = i;
            else {
                if(path[u-1] < i) path[u] = i;
                else continue;
            }
            dfs(u+1);
        }
    }
}

C/C++

#include <bits/stdc++.h>

using namespace std;

const int N = 30;

int path[N];

int n,m;

void dfs(int u){
    if(u == m){
        for(int i = 0;i < m;i++) cout << path[i] << " ";
        cout << endl;
        return;
    }
    for(int i = 1;i <= n;i++){
        if(u == 0) path[u] = i;
        else{
            // 前一位要比这一位小
            if(path[u-1] < i) path[u] = i;
            else continue;
        }
        dfs(u+1);
    }
}

int main(){
    cin >> n >> m;
    dfs(0);
    return 0;
}

简单的斐波那契数列

java

import java.util.*;
public class Main{
    static Scanner in = new Scanner(System.in);
    static int n,a = 0,b  = 1;
    public static void main(String[] args){
        n = in.nextInt();
        for(int i = 0;i < n;i++){
            System.out.printf("%d ",a);
            int temp = a + b;
            a = b;
            b = temp;
        }
    }
}

C/C++

#include <bits/stdc++.h>

using namespace std;

// 递推公式
// a[i] = a[i-1] + a[i-2]

int n;

int main(){
    int a = 0,b = 1;
    cin >> n;
    for(int i = 0;i < n;i++){
        cout << a << " ";
        int temp = a + b;
        b = a;
        a = temp;
    }
    cout << endl;
    return 0;
}

费解的开关

想写出这个题目，首先得分析出几个点：

  1. 每个灯泡只能被摁一次，因为摁两次不会有任何改变，并且还多了步数
  2. 摁的顺序是无所谓的，先摁哪个再摁哪个是没关系的。

依靠上面两个结论，我们来看这一题：

  1. 我们可以先只看第一行，第一行我们可以随意摁，但是每个灯泡只能被操作一次。
  2. 第一行被操作过了，轮到第二行，此时第一行如果还有灭的，只能通过第二行来将其熄灭。逻辑就是这样，下面的每一行的灯泡是否操作，都是看上一行灯灯泡的状态。

因此：

  1. 我们枚举第一行的所有状态
    1. 怎么枚举，第一行一共5个灯泡、每个灯泡开或关有两种状态、那么就是2^5=32种状态
  2. 之后根据当前第一行的状态去操作后续的行
  3. 到最后一行、看是否有开的，如果有，说明不能全灭

C/C++

#include <bits/stdc++.h>

using namespace std;

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<PII> ans;
    // 枚举所有的情况
    for(int op = 0;op < 1 << 16;op++){
        memcpy(backup,g,sizeof g);  // 备份
        // 这一种情况的操作
        vector<PII> 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
    1. 其中a、b、c 就是1~9的组合
  2. 再简化 就是 n * c = a * c + b
    1. 这样我们只要枚举所有的a、b、c
    2. 能够让上面的等式成立即可
  3. 如何枚举所有所有的a、b、c呢？
    1. 通过之前的递归实现排列型枚举、也是全排列即可

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(n*c == a*c + 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
    1. 等式中三个位置数，知道其中两个即可
    2. 那么我们枚举a和c，就可以得到b
    3. 判断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 = n*c - a*c;
    // 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;
    }
    
}
[AcWing蓝桥杯]之递归与递推（C++题解）
lihua777的博客
02-20 904
[AcWing蓝桥杯]之递归与递推（C++题解）
蓝桥杯一周冲刺夺奖计划-递推法与递归法
qq_53283658的博客
04-06 417
目录 递推法与递归法 递推算法的特点 斐波纳契数列 fibonacci 问题 存储型的递推与递归 数字三角形问题 总结 递推法与递归法 递推法： 递推法是一种非常重要的数学方法，不仅在数学领域有着广泛的运用，在其他领域也有着较高的实用性。在计算机中，递推法是用于数值求解的一个重要算法。 知识点 递推算法 递归算法 递推算法的特点 一个问题的求解需要大量重复计算，在已知的条件和所求问题之间总存在着某种相互联系的关系，在计算时，我们需要找到这种关系，进行计算（递推关系式）。.
【蓝桥杯专题】 递归 &递推 （C++ | 洛谷 | acwing）
CPT1024
03-06 779
文章目录 【蓝桥杯专题】 递归 &递推 （C++ | 洛谷 | acwing） 复习 P5534 【XR-3】等差数列 P4994 终于结束的起点 P1028 [NOIP2001 普及组] 数的计算 波动数列 [递归]母牛的故事 蓝桥杯：耐摔指数
【AcWing蓝桥杯】C++AB组 递归与递推
m0_64263546的博客
01-12 199
【AcWing蓝桥杯】递归与递推
蓝桥杯第二讲--递推【例题】
佛系更新
01-17 3724
蓝桥杯官网：蓝桥杯大赛——全国大学生TMT行业赛事 本博客讲解 蓝桥杯C/C++ 备赛所涉及算法知识，此博客为第二讲：递推【例题】 本篇博客所包含习题有： 简单斐波那契 费解的开关 博客内容以题代讲，通过讲解题目的做法来帮助读者快速理解算法内容，需要注意：学习算法不能光过脑，更要实践，请读者务必自己敲写一遍本博客相关代码！！！
蓝桥杯定向刷题：递归篇
热门推荐
qq_44459787的博客
04-13 1万+
1、合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int v
蓝桥杯刷题真解析-小白到大师的进阶之路
06-03
《蓝桥杯刷题真解析-小白到大师的进阶之路》是一份旨在帮助参赛者逐步提升编程技能、深入理解算法与数据结构的资源集合。"蓝桥杯"是一项全国性的编程竞赛，对于计算机科学和技术专业学生以及热衷于编程的爱好者来说...
蓝桥杯刷题总结-合集(持续更新)
Destiny_159的博客
12-08 2407
蓝桥杯刷题总结 待办： 0. 刷题前须知 1. 递归与递推 2. 二分 3. 前缀和 4. 数学 5. 枚举 6. 模拟 7. 排序 8. 双指针 9. BFS 10. 图论 11. 树状数组 12. 线段树 13. 贪心 14. 数论 15. 简单DP 16. 复杂DP 17. 杂题 18. 十一届蓝桥杯真题 19. 十二届蓝桥杯真题 BaseOn ： https://www.acwing.com 0、刷提前的须知 1、输入 in.next()和in.ne
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题递归倒置字符数组.zip
04-12
在C++编程语言中，"递归倒置字符数组"是一个常见的算法问题，它涉及到对字符串的处理和递归的概念。在蓝桥杯竞赛中，这样的题目旨在考察参赛者的逻辑思维能力和对C++语言基础的掌握程度。让我们深入探讨这个问题。 ...
蓝桥杯刷题LanQiaoCup Python解答蓝桥杯省赛真题之从入门到真题
06-02
【蓝桥杯刷题LanQiaoCup Python解答】：蓝桥杯竞赛是针对编程爱好者和学生的一项重要赛事，旨在提升参赛者的编程能力和逻辑思维。本资源集合了Python语言解答蓝桥杯省赛的真题，涵盖了从基础概念到实际问题解决的多...
蓝桥杯练习（递归）
qq_54641516的博客
02-28 744
母牛的故事：一头母牛每年初生一头小母牛，小母牛到第四年时也开始生小牛，第n年，一共会有多少头牛？ 这是一个典型的递归问题，可以参考斐波拉契数列,来理解递归思想。 第n年 1 2 3 4 5 6 7 f [n] 头牛 1 2 3 4 6 9 13 找规律，明显 f [n] = f [n-1] + f [ n-3 ] ； 附上代码（0<55<n) 数组方式解决，比较清晰，也可以自定义函数。 #inc
蓝桥杯刷题-一步一步实现递归
zhou_hao_yan的博客
01-23 4689
直接上代码(附有注解) package changer.day02; /** * 1.切蛋糕思维 * 2.看看有没有递推公式,或等价转换 */ public class _02_1什么是递归 { public static void main(String[] args) { // System.out.println(f1(10)); // f2(1,10); // System.out.println(f3(new int[]{1,1,1,1
第十三届蓝桥杯省赛C++B组 真题题解（详细讲解+代码分析）看这篇就够了~~~
满天星的博客
04-12 5789
第十三届蓝桥杯省赛C++B组 真题题解A.九进制转十进制B.顺子日期C.刷题统计D.修剪灌木E.X 进制减法F.统计子矩阵G.积木画H.扫雷I.李白打酒加强版J.砍竹子 A.九进制转十进制 题目描述 九进制正整数(2022)9转换成十进制等于多少？ 思路 2 * 9^3 + 0 * 9^2 + 2 * 9^1 + 2 * 9^0=1478 答案：1478 B.顺子日期 题目描述 小明特别喜欢顺子。顺子指的就是连续的三个数字：123、456等。顺子日期指的就是在日期的yyyymmdd表示法中，存在任意连续的三
翻硬币
qq_52051345的博客
12-08 610
小明正在玩一个“翻硬币”的游戏。 桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。 比如，可能情形是：oo*oooo 如果同时翻转左边的两个硬币，则变为：oooo***oooo 现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？ 我们约定：把翻动相邻的两个硬币叫做一步操作。 输入格...
重邮acm校赛 F.火柴棍
weixin_62403934的博客
05-08 572
#include<bits/stdc++.h> #define x first #define t second using namespace std; typedef pair<int, int> PII; const int N=10010; int n,m,a[10]= {0,2,5,5,4,5,6,3,7,6}; string dp[N]; PII num[20]; bool cmp(PII &l,PII &r) { if(l.x == r.
翻硬币问题
kerbcurb的专栏
07-15 2066
翻硬币问题翻硬币问题有好几种。其中的一种是这样的：桌子上有q = m + n枚硬币，m正面朝上，n枚反面朝上，每一轮翻p枚，在每一轮翻币的时候，被翻的同一枚硬币只能翻一次。问最少多少次能把所有的硬币翻成全部正面或者反面朝上？根据问题的描述，问题实际上隐含：m 、n、 p > 0，
(蓝桥杯C/C++)——搜索
2402_82385099的博客
11-09 653
就是将搜索过程中会重复计算且结果相同的部分保存下来，作为一个状态，下次访问到这个状态时直接将这个子搜索的结果返回，而不需要再重新算一遍。通常会使用数组或map来进行记忆化，下标一般和dfs的参数表对应。注意使用记忆化需要保证重复计算的结果是相同的，否则可能产生数据失真。其实就是将搜索过程当中一些不必要的部分直接剔除掉，因为搜索过程构成了一棵树，剔除不必要的部分，就像是在树上将树枝剪掉，故名剪枝。
蓝桥杯 Python组-神奇闹钟（datetime库）
AuRoRamth的博客
11-05 1276
传送门： 0神奇闹钟 - 蓝桥云课​​​​​​小蓝发现了一个神奇的闹钟，从纪元时间（1970 年 11 日 00：00：00）开始，每经过 x 分钟，这个闹钟便会触发一次闹铃 (纪元时间也会响铃)。这引起了小蓝的兴趣，他想要好好研究下这个闹钟。对于给出的任意一个格式为 уууу-MM-ddHH:mm:ss 的时间，小蓝想要知道在这个时间点之前 (包含这个时间点) 的最近的一次闹铃时间是哪个时间?注意，你不必考虑时区问题。输入格式输入的第一行包含一个整数 T，表示每次输入包含 T 组数据。接下来依次描述
(蓝桥杯C/C++)——动态规划(DP)
最新发布
2402_82385099的博客
11-09 426
DP(动态规划)全称DynamicProgramming，是运筹学的一个分支，是一种将复杂问题分解成很多重叠的子问题，并通过子问题的解得到整个问题的解的算法。在动态规划中有一些概念:状态:就是形如dp[il[il=val的取值，其中i，i为下标，也是用于描述、确定状态所需的变量,val为状态值。状态与状态之间的转移关系，一般可以表示为一个数学表达式，转移方向决迭代或递归方向。也就是题目所求的状态，最后的答案。
蓝桥杯--装饰珠用递归
10-19
根据提供的引用内容，没有提到蓝桥杯--装饰珠可以用递归解决。因此，我无法为您提供关于蓝桥杯--装饰珠用递归的回答。但是，我可以为您介绍递归的概念和用途。 递归是一种解决问题的方法，它将问题分解为更小的子问题，直到问题的规模足够小，可以直接解决。递归通常涉及函数调用本身，这也是递归的特点之一。 递归可以用于解决许多问题，例如计算阶乘、斐波那契数列、汉诺塔等。在编写递归函数时，需要注意递归终止条件，否则递归将无限进行下去，导致程序崩溃。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值