蓝桥杯集训·每日一题Week2

最新推荐文章于 2024-08-17 07:45:00 发布
最新推荐文章于 2024-08-17 07:45:00 发布
阅读量472 收藏 2
点赞数
分类专栏： AcWing算法学习 算法学习 文章标签： 蓝桥杯 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51624761/article/details/129631879
版权

递归

AcWing 1497. 树的遍历（每日一题）

在这里插入图片描述
思路：

给定一棵树的后序和中序遍历序列可以唯一确定一棵二叉树。

对于后序遍历序列，根节点一定出现在最后面，这样可以唯一确定根节点。

对于中序遍历序列，根节点一定出现在左右子树之间，结合后序遍历序列可以确定左右子树。

递归地执行上述过程，可以构造出一棵二叉树，最后再 b f s bfs bfs 一下输出中序遍历序列。

代码：

#include <iostream>
using namespace std;

const int N = 35;

// p存储根节点在中序遍历中的位置
int l[N], r[N], p[N];
int back[N], mid[N];
int q[N];
int n;


// 后序 起点 终点 中序 起点 终点
int generate(int al, int ar, int bl, int br)
{
    if (al > ar) return 0;
    int root = back[ar];
    int k = p[root];
    
    // ar - al = k - 1 - bl  ar = al + k - 1 - bl 
    l[root] = generate(al, al + k - 1 - bl, bl, k - 1);
    // bl - k - 1 = ar - 1 - al   al = ar - 1 - bl + k + 1 = ar -bl + k
    r[root] = generate(ar - br + k, ar - 1, k + 1, br);
    
    return root;
}

void bfs(int root) 
{
    int hh = 0, tt = -1;
    q[++tt] = root;
    while (hh <= tt) 
    {
        int t = q[hh++];
        printf("%d ", t);
        if (l[t]) q[++tt] = l[t];
        if (r[t]) q[++tt] = r[t];
    }
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> back[i];
    for (int i = 1; i <= n; i++) 
    {
        cin >> mid[i];
        p[mid[i]] = i;
    }
    
    int root = generate(1, n, 1, n);
    bfs(root);
    return 0;
}

并查集

AcWing 1249. 亲戚（每日一题）

在这里插入图片描述
思路：

并查集可以高效判断两个节点是否在一个集合中。构造并查集要实现初始化，查询以及合并操作。

(1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * @Description
 * @Author: PrinceHan
 * @CreateTime: 2023/2/25 16:37
 */
public class Main {
    static final int N = 20005;
    static int n, m;
    static int[] p = new int[N];
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] nk = in.readLine().split(" ");
        n = Integer.parseInt(nk[0]);
        m = Integer.parseInt(nk[1]);

        for (int i = 1; i <= n; i++) p[i] = i;

        while (m-- != 0) {
            String[] s = in.readLine().split(" ");
            int a = Integer.parseInt(s[0]), b = Integer.parseInt(s[1]);
            int aa = find(a), bb = find(b);
            if (aa == bb) continue;
            p[aa] = bb;
        }

        int q = Integer.parseInt(in.readLine().split(" ")[0]);

        while (q-- != 0) {
            String[] s = in.readLine().split(" ");
            int c = Integer.parseInt(s[0]), d = Integer.parseInt(s[1]);
            if (find(c) == find(d)) out.println("Yes");
            else out.println("No");
        }
        out.flush();
    }

    public static int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

}

AcWing 836. 合并集合（算法基础课）

在这里插入图片描述
代码：

#include <iostream>
using namespace std;

const int N = 100005;
int p[N];
int n, m;

// 查询祖宗节点
int find(int x)
{
    // 路径压缩
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

// 合并集合
void merge(int a, int b)
{
    // 同一个祖先 不需要合并
    if (find(a) == find(b)) return;
    // a的祖先的父亲是b的祖先 操作可以互换
    p[find(a)] = find(b); 
}

int main()
{
    scanf("%d%d", &n, &m);
    
    // 初始化并查集
    for (int i = 1; i <= n; i++) p[i] = i;
    
    while (m--)
    {
        char op[2];
        int a, b;
        
        scanf("%s%d%d", op, &a, &b);
        
        if (op[0] == 'M') merge(a, b);
        else cout << (find(a) == find(b) ? "Yes" : "No") << endl;
    }
}

AcWing 837. 连通块中点的数量（算法基础课）

在这里插入图片描述
思路：

需要维护一个数组，用来记录集合中的节点数量

(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);

代码：

#include <iostream>
using namespace std;

const int N = 100005;
int p[N], cnt[N];
int n, m;

// 查询祖宗节点
int find(int x)
{
    // 路径压缩
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

// 合并集合
void merge(int a, int b)
{
    // 同一个祖先 不需要合并
    if (find(a) == find(b)) return;
    // a的祖先的祖先是b的祖先 操作可以互换
    cnt[find(b)] += cnt[find(a)];
    p[find(a)] = find(b); 
}

int main()
{
    scanf("%d%d", &n, &m);
    
    // 初始化并查集
    for (int i = 1; i <= n; i++) p[i] = i, cnt[i] = 1;
    
    while (m--)
    {
        char op[5];
        int a, b;
        scanf("%s", op);
        if (op[0] == 'C') 
        {
            scanf("%d%d", &a, &b);
            merge(a, b);
        }
        else if (op[1] == '1') 
        {
            scanf("%d%d", &a, &b);
            printf(find(a) == find(b) ? "Yes\n" : "No\n");
        }
        else 
        {
            scanf("%d", &a);
            printf("%d\n", cnt[find(a)]);
        }
    }
    return 0;
}

哈希表

AcWing 2058. 笨拙的手指（每日一题）

在这里插入图片描述

思路：

对于每个二进制表示，可以枚举每一个错误的位置，要注意一个特殊情况：如果一个二进制表示的长度大于1并且含有前导0，则需要跳过这种情况。注意一切操作都是要先修改错误位置的元素，再进行判断。对符合条件的二进制序列，转化为十进制数加入哈希表中。通过上述步骤将三进制的序列转化为十进制数，如果在哈希表中存在，则该数就是所求的答案。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.HashSet;

/**
 * @Description
 * @Author: PrinceHan
 * @CreateTime: 2023/3/7 21:06
 */
public class Main {

    public static int base(String a, int b) {
        int res = 0;
        for (int i = 0; i < a.length(); i++) {
            res = res * b + a.charAt(i) - '0';
        }
        return res;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String x = in.readLine();
        String y = in.readLine();
        HashSet<Integer> res = new HashSet<>();

        for (int i = 0; i < x.length(); i++) {
            char[] s = x.toCharArray();
            s[i] ^= 1;
            if (s.length > 1 && s[0] == '0') continue;
            res.add(base(new String(s), 2));
        }


        for (int i = 0; i < y.length(); i++) {
            for (int j = 0; j < 3; j++) {
                char[] s = y.toCharArray();
                if (s[i] - '0' == j) continue;
                s[i] = (char) (j + '0');
                if (s.length> 1 && s[0] == '0') continue;
                int n = base(new String(s), 3);
                if (res.contains(n)) {
                    out.println(n);
                }
            }
        }
        out.flush();
    }
}

AcWing 840. 模拟散列表（算法基础课）

在这里插入图片描述

拉链法

在这里插入图片描述

#include<iostream>
#include <cstring>
using namespace std;

const int N = 100003;
int h[N], e[N], ne[N], idx;
int n;

void insert(int x)
{
    int k = (x % N + N) % N;
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx++;
}

bool find(int x)
{
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i])
        if (e[i] == x) return true;
        
    return false;
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);
    char op[2];
    int x;
    while (n--)
    {
        scanf("%s%d", op, &x);
        if (op[0] == 'I') insert(x);
        else printf(find(x) ? "Yes\n" : "No\n");
    }
    return 0;
}

开放寻址法，范围2~3倍
在这里插入图片描述

#include<iostream>
#include <cstring>
using namespace std;

const int N = 200003, null = 0x3f3f3f3f; // 范围2~3倍 质数
int h[N];
int n;

// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
int find(int x)
{
    int k = (x % N + N) % N;
    
    while (h[k] != null && h[k] != x)
    {
        k++;
        if (k == N) k = 0;
    }
        
    return k;
}

int main()
{
    scanf("%d", &n);
    // memset 按字节赋值 后八位
    memset(h, 0x3f, sizeof h);
    char op[2];
    int x;
    while (n--)
    {
        scanf("%s%d", op, &x);
        int k = find(x);
        if (op[0] == 'I') h[k] = x;
        else printf(h[k] != null  ? "Yes\n" : "No\n");
    }
    return 0;
}

AcWing 841. 字符串哈希（算法基础课）

在这里插入图片描述

核心思想： 将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧： 取模的数用 2 64 2^{64} 264，这样直接用 unsigned long long 存储，溢出的结果就是取模的结果
注意： 字符串从1的位置开始存。前 l l l 位字符串的哈希值是 h [ l ] h[l] h[l]，前 r r r 位字符串的哈希值是 h [ r ] h[r] h[r]，则 l ∼ r l \sim r l∼r 之间字符串（包含端点）的哈希值可以表示为：
h [ l ∼ r ] = h [ 1 ∼ r ] − h [ 1 ∼ l − 1 ] ∗ P r − l + 1 \begin{aligned} h[l \sim r] &= h[1 \sim r] - h[1 \sim l - 1] * P ^{r - l + 1} \end{aligned} h[l∼r]​=h[1∼r]−h[1∼l−1]∗Pr−l+1​

在这里插入图片描述

在这里插入图片描述

模板

typedef unsigned long long ull;
ull h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

// 计算子串 str[l ~ r] 的哈希值
ull get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

代码：

#include <iostream>
using namespace std;

typedef unsigned long long ull;

const int N = 100005, P = 131;
ull h[N], p[N];
char str[N];

ull get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
    int n, m;
    scanf("%d%d%s", &n, &m, str + 1);
    
    p[0] = 1;
    for (int i = 1; str[i]; i++)
    {
        h[i] = h[i - 1] * P + str[i];
        p[i] = p[i - 1] * P;
    }
    
    while (m--)
    {
        int l1, r1, l2, r2;
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        if (get(l1, r1) == get(l2, r2)) printf("Yes\n");
        else printf("No\n");
    }
    
    return 0;
}

KMP

AcWing 141. 周期（每日一题）

在这里插入图片描述
思路：

本质上是使用 K M P KMP KMP 算法 求出最短循环节。
对一段字符序列 s [ 1 ∼ i ] s[1 \sim i] s[1∼i]，如果 i − n e [ i ]   m o d   n e [ i ] = 0 i - ne[i] \bmod ne[i] = 0 i−ne[i]modne[i]=0，则 s [ 1 ∼ i ] s[1 \sim i] s[1∼i] 是字符序列 s [ 1 ∼ i ] s[1 \sim i] s[1∼i] 的最短循环节，其他循环节长度为 它的整倍数。

求next数组：

// p[0 ~ n - 1]
for (int i = 2, j = 0; i <= n; i++) {
	while (j != 0 && p[i - 1] != p[j]) j = ne[j];
	if (p[i - 1] == p[j]) j++;
	ne[i] = j;
}
// p[1 ~ n]
for (int i = 2, j = 0; i <= n; i++) {
	while (j != 0 && p[i] != p[j + 1]) j = ne[j];
	if (p[i] == p[j + 1]) j++;
	ne[i] = j;
}

代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

/**
 * @Description
 * @Author: PrinceHan
 * @CreateTime: 2023/3/8 17:26
 */
public class Main {
    static final int N = 1000010;
    static int[] ne = new int[N];
    static int n;

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in = new StreamTokenizer(br);
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static void main(String[] args) throws IOException {
        int idx = 1;
        while (true) {
            n = Integer.parseInt(br.readLine());
            if (n == 0) break;
            String s = br.readLine();
            char[] p = s.toCharArray();
            for (int i = 2, j = 0; i <= n; i++) {
                while (j != 0 && p[i - 1] != p[j]) j = ne[j];
                if (p[i - 1] == p[j]) j++;
                ne[i] = j;
            }

            out.printf("Test case #%d\n", idx++);

            for (int i = 2; i <= n; i++) {
                if (ne[i] != 0 && i % (i - ne[i]) == 0)
                    out.printf("%d %d\n", i, i / (i - ne[i]));
            }

            out.println();
        }
        out.flush();
    }
}

AcWing 831. KMP字符串（算法基础课）

在这里插入图片描述

// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
求模式串的Next数组：
for (int i = 2, j = 0; i <= m; i ++ )
{
    while (j && p[i] != p[j + 1]) j = ne[j];
    if (p[i] == p[j + 1]) j ++ ;
    ne[i] = j;
}

// 匹配
for (int i = 1, j = 0; i <= n; i ++ )
{
    while (j && s[i] != p[j + 1]) j = ne[j];
    if (s[i] == p[j + 1]) j ++ ;
    if (j == m)
    {
        j = ne[j];
        // 匹配成功后的逻辑
    }
}

代码：

#include<iostream>
using namespace std;

const int N = 1000010;
char s[N], p[N];
int n, m, ne[N];


int main()
{
    cin >> n >> p + 1 >> m >> s + 1;
    
    for (int i = 2, j = 0; i <= n; i++)
    {
        while (j && p[i] != p[j + 1]) j = ne[j];
        if (p[i] == p[j + 1]) j++;
        ne[i] = j;
    }
    
    for (int i = 1, j = 0; i <= m; i++)
    {
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j++;
        if (j == n) printf("%d ", i - n);
    }
    
    return 0;
}
理想-
关注
专栏目录
【蓝桥杯集训100题】scratch绘制扇子 蓝桥杯scratch比赛专项预测编程题 集训模拟练习题第28题
青少年编程学习指导
08-23 1474
​ scratch绘制扇子 蓝桥杯集训100题第28题模拟练习解析 此题曾经作为第十届省赛的真题考过 一、题目要求 以坐标（0,0）点为中心绘制一把扇子；扇面和扇把都是三分之一圆，扇面的半径 为 100 左右，扇把的半径为 20 左右。 编程实现 每次点击绿旗后，舞台背景为白色，舞台上不显示任何内容。然后连贯地画出 扇子图案，中间不可停顿。 画出的扇子颜色为蓝色，画笔粗细为 1，扇面和扇把的张角都为三分之一圆 （120 度），扇面的半径为 100 左右，扇把的半径为 20 左右。 坐标
【蓝桥杯集训100题】scratch猜数字游戏 蓝桥杯scratch比赛专项预测编程题 集训模拟练习题第25题
最新发布
青少年编程学习指导
08-18 773
​ scratch抽奖游戏 蓝桥杯集训100题第21题模拟练习解析 一、题目要求 编程实现 设计制作一个猜数游戏，随机生成一个数（这个数为 0~9 之间的某一个数），给 每位挑战者 9 次机会，猜这个数，挑战者无论怎样，永远不会猜中这个数，机会用完后，能报出这个随机数是多少。（例如：猜了 0~8 这 9 个数字，但最后就是提醒你随机数字是 9）。每猜一次，都会说“NO”，猜完第 9 次时，会提示：“Sorry,Num is X(正确的数字)”。 ​
蓝桥杯官网练习题和测评数据-算法训练1-40(40题)
04-06
蓝桥杯练习题概览 试题集名称 试题总数 更新时间 入门训练 4 2013/10/9 基础练习 30 2013/11/3 算法训练 180 2018-03-09 算法提高 220 2018-03-09 历届试题 55 2017-12-18 包括题目和测试数据
蓝桥杯--每日一练
qq_57298535的博客
01-26 345
1.题目 2.做题思路 首先要读出一个字符串 然后对26个字符进行整形数组储存 这样不仅能区分字母和顺序 都可以进行操作 这个题说 按最小的输出 如果相同的话 这样就避免这个操作 比较简洁 做完之后用字符串的charAT（）方法也能进行解决 感兴趣的可以试试 3.代码如下 package hanjia; import java.util.Scanner; public class J28 { public static void main(String[] args) { Scann.
蓝桥杯每日一练
m0_58290966的博客
01-20 200
问题一： 将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 //思路：读入一行字符串，将字符串用tocharAt()转换为字符数组。倒序输出 import java.util.Scanner; public class Main3{ public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.nextL...
蓝桥杯集训包,蓝桥杯训练
09-10
集训包中的核心资料是"蓝桥杯集训包.pdf"，这是一份详尽的教学指南，很可能包含了以下几个方面的内容： 1. **Scratch基础知识**：介绍Scratch的基本界面、角色与舞台的概念，以及如何创建和控制角色的移动、旋转等...
【蓝桥杯集训100题】scratch斐波那契数列 蓝桥杯scratch比赛专项预测编程题 集训模拟练习题第24题
青少年编程学习指导
08-17 793
scratch斐波那契数列 蓝桥杯集训100题第24题模拟练习解析 一、题目要求 编程实现 如果有一个数列，第 1 项是 0，第 2 项是 1。这个数列从第 3 项开始，每一项都 等于前两项之和。0, 1, 1, 2, 3, 5, 8, 13, 21…….，这样的数列叫斐波那契数列。斐 波那契数列在现代物理、准晶体结构、化学等领域都有直接的应用。为此，美国数学 会从 1963 起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方 面的研究成果。
蓝桥杯Python集训课复习题一模拟题附答案
04-13
蓝桥杯Python集训课复习题一模拟题附答案
小明的彩灯（差分）
m0_52547988的博客
04-02 586
题目描述 小明拥有NN个彩灯，第ii个彩灯的初始亮度为a_iai​。 小明将进行QQ次操作，每次操作可选择一段区间，并使区间内彩灯的亮度+x+x（xx可能为负数）。 求QQ次操作后每个彩灯的亮度（若彩灯亮度为负数则输出00）。 输入描述 第一行包含两个正整数N，QN，Q，分别表示彩灯的数量和操作的次数。 第二行包含NN个整数，表示彩灯的初始亮度。 接下来QQ行每行包含一个操作，格式如下： l r x，表示将区间l\sim rl∼r的彩灯的亮度+x+x。...
蓝桥杯每日一练day1
a18239425039的博客
03-03 140
每日一练
蓝桥杯-每日一练04
weixin_45394944的博客
01-04 215
蓝桥杯
【每日一题】蓝桥杯加练 | Day07
湫喃
03-10 525
蓝桥杯 Day07
蓝桥杯 题库 简单 每日十题 day1
weixin_74774974的博客
09-15 955
01 空间 02 蛇形填数 03 组队 04 裁纸刀 05 时间显示 06 既约分数 07 特别数的和 08 年号字串 09 排列字母 10ASC
Java初学：杨辉三角
Zeker62的博客
09-21 166
杨辉三角：java实现 1，杨辉三角的概念？ 杨辉三角，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。帕斯卡（1623----1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。杨辉三角是中国古代数学的杰出研究成果之一，它把二项式系数图形化，把组合数内在的一些代数性质直观地从图形中体现出来，是一种离散型的数与形的结合 代码实现 package 杨辉三角; public class Yanghuisanjiao //编写类的名称 { public sta
倪文迪陪你学蓝桥杯2021寒假每日一题：2.1日（2019省赛A组第10题）
罗勇军的博客
02-01 4576
组合数问题，lucas定理。
【蓝桥杯 每日一练】反倍数
零碎@流年絮语 的博客
02-16 597
【问题描述】 给定三个整数 a, b, c，如果一个整数既不是 a 的整数倍也不是 b 的整数倍还不是 c 的整数倍，则这个数称为反倍数。 请问在 1 至 n 中有多少个反倍数。 【输入格式】 输入的第一行包含一个整数 n。 第二行包含三个整数 a, b, c，相邻两个数之间用一个空格分隔。 【输出格式】 输出一行包含一个整数，表示答案。 【样例输入】 30 2 3 6 【样例输出】 10 【样例说明】 以下这些数满足要求：1, 5, 7, 11, 13, 17, 19, 23, 25, 29。 【评测用例
《每日一练》合集
肥宅快乐博客
12-18 4757
饭可以一日不吃，觉可以一日不睡，书不可以一日不读。 ——毛泽东 每天一题，每天一个知识点，每天一次头脑风暴，只为实现理想的生活！！！ 请诸君共勉！！！ 文章目录2020年八月九月十月十一月十二月凭一键三连截图即可找我领取《每日一练》最新、最全版PDF文件！！！ 2020年 八月 每日一练（一） 九月 每日一练（二） 每日一练（三） 每日一练（四） 每日一练（五） 每日一练（六） 每日一练（七） 十月 每日一练（八） 每日一练（九） 每日一练（十） 每日一练（十一） 每日一练（
蓝桥杯算法集训：Java填空题集精华解析
"算法集训之结果填空题集二（Java）是一份针对蓝桥杯竞赛的参考资料，涵盖了多个有趣的编程题目，旨在提升参赛者的算法理解和实践能力。以下是部分知识点的详细解析： 1. 欧拉与鸡蛋问题：这是个经典的逻辑推理题目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值