小石崽的小窝

网站更新啦

Thu, 19 Feb 2026 00:26:00 GMT

关于本网站更新的说明

前几天看到一个群友Pinpe的网站，感觉蛮漂亮的。随后看了一眼仓库，唔，发现一只好可爱的正太（；于是关注了一下这个仓库:

::github{repo="saicaca/fuwari"}

随后便开始改造我的网站了。（其实早就想改啦）

我属于是最一开始就去折腾了一下自动化部署，是参照柳神大佬的博客的：
https://blog.liushen.fun/
感觉还挺方便的（
就是腾讯云的告警不知道咋关（qwq找不到；GitHub在使用一个美国ip登录我的网站）。

但是不得不说，这个速度还蛮快的。构建+部署+上传服务器总共1min不到就能成。感觉好不错，就是写文章太麻烦了。后面看看能不能找/改一个编辑器来。嘿嘿。

自豪地使用Fuwari主题。

Linux 基础 & Python 控制流

Mon, 08 Dec 2025 11:24:00 GMT

Linux 基础使用 & Python 控制流

Linux 基础使用

注意：机房开启了保存电脑记录，所以请记住你的座位。

本节课开始我们初步开始使用Linux。Linux在全世界有广泛的使用，例如我们的安卓手机都基于Linux内核（Android/Linux），以及80%的线上服务都在Linux服务器上运行（GNU/Linux）。

本次我们使用NOI Linux 2.0（基于Ubuntu）进行学习活动。

如何打开编辑器。点击左下角九个点的菜单标识可以打开应用菜单。选择VS Code，在插件栏下载中文及Python插件，重启VS Code即可开始编辑。

Linux 是当今计算领域中至关重要的操作系统。它不仅广泛应用于服务器领域（约80%的线上服务运行在基于GNU/Linux的服务器上），也是移动设备（Android基于Linux内核）、嵌入式系统、超级计算机等领域的核心技术基础。

本次课程我们将使用 NOI Linux 2.0（基于 Ubuntu 20.04 LTS）作为学习环境。这是一个专门为编程竞赛和学习设计的Linux发行版，预装了丰富的开发工具。

1. 开发环境配置指南

1.1 编辑器安装与配置

点击屏幕左下角的应用程序菜单图标（九宫格图标）即可打开应用程序菜单。

联网后，在终端（使用Alt+Ctrl+T打开）中输入

sudo apt update && sudo apt install vlc firefox -y

如果有时间可以使用

sudo apt upgrade -y

进行全局更新。在搜索框中输入 "VS Code" 或浏览找到 Visual Studio Code: 首次启动 VS Code 后，需要进行以下基础配置：

-   **语言包安装**：点击左侧活动栏的扩展图标（四个方块形状），搜索 "Chinese"，安装 Microsoft 提供的中文语言包

-   **Python 支持**：同样在扩展商店中搜索 "Python"，安装 Microsoft 官方的 Python 扩展

-   **重启生效**：安装完成后需要重启 VS Code 使配置生效

接下来重启浏览器，就可以~~enjoy BiliBili~~写代码了。

常用命令详解：


# 1. 更新软件包索引
sudo apt update
# - sudo: 以管理员权限执行命令
# - apt: Ubuntu/Debian系统的包管理工具
# - update: 从软件源服务器获取最新的软件包列表信息

# 2. 安装常用软件
sudo apt install vlc firefox -y
# - install: 安装指定软件包
#   - vlc: 强大的多媒体播放器
#   - firefox: 网页浏览器
# - -y: 自动确认安装，无需手动输入"y"

# 3. 升级已安装的软件（可选，时间充足时执行）
sudo apt upgrade -y
# - upgrade: 将所有已安装的软件升级到最新版本
# - 注意：此过程可能需要较长时间和网络带宽

1.3 基础命令扩展学习

除了上述命令，以下基础命令也值得掌握：


# 查看当前目录
pwd

# 列出目录内容
ls
ls -la  # 显示详细信息，包括隐藏文件

# 切换目录
cd Documents  # 进入Documents目录
cd ..         # 返回上一级目录
cd ~          # 返回用户主目录

# 创建目录和文件
mkdir python_projects  # 创建新目录
touch hello.py         # 创建空文件

# 查看文件内容
cat hello.py           # 显示整个文件内容
less hello.py          # 分页查看（按q退出）

Python 控制流

我们之前写的程序，都是按顺序执行的。有些时候，我们需要重复执行一些相似的操作，或者在不同情况下执行不同的工作，这个时候就需要用到循环/分支结构控制程序流程了。

请以 写出一个输出1到n中的所有质数的程序。其中n由输入给出。 为目标学习下方文档并上网查找资料。

分支结构

例如我在天晴的时候会去骑自行车，下雨的时候我在家里看罗小黑，那么该写一个什么程序来猜测我的行程呢？

我们可以使用if语句

status = input("今天是晴天吗？请输入Yes或No: ")

if status == "Yes":
	print("今天副社长石头要去骑车")
elif status == "No":
	print("今天副社长石头回去看罗小黑哦!喵~")
else:
	print("你输入的不是Yes或No吧？检查一下哦")

其中else意为否则，elif是else if的缩写。在第一个if语句为否的情况下，就会执行下面的否则语句。else和elif的区别在于，elif还需要满足另一个条件。由此可知，else需放在最后，因为任何不满足第一条if语句的情况都满足else。

循环结构

有的时候我们需要重复进行某些事情，例如一年三百六十五天，我就要吃1095次饭。要是每一次都重新写一遍代码，那么将会无比麻烦。

于是就有了循环结构。循环结构有while和for两种。

while 循环

while 循环会在条件为真时重复执行一段代码。

count = 0
while count < 5:
    print("这是第", count+1, "次循环")
    count += 1

for 循环

for 循环常用于遍历序列（如列表、元组、字符串）或范围。

for i in range(5):
    print("这是第", i+1, "次循环")

Python 学习任务：输出 1 到 n 中的所有质数

任务分析

质数（素数）是指大于1且只能被1和自身整除的自然数。我们需要：

获取用户输入的整数 n
从 2 到 n 依次判断每个数是否为质数
输出所有质数

实现步骤

使用 input 获取用户输入的 n，并转换为整数
使用外层循环遍历从 2 到 n 的每个数
对内层循环判断当前数是否为质数：
- 质数判断：从 2 到该数的平方根，判断是否能整除
如果是质数，则输出

示例代码

n = int(input("请输入一个整数 n："))

print(f"1 到 {n} 中的所有质数为：")

for num in range(2, n + 1):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(num, end=" ")

代码解释

int(input(...))：获取用户输入并转换为整数
range(2, n + 1)：生成从 2 到 n 的整数序列
num ** 0.5：计算 num 的平方根，用于优化质数判断
break：一旦发现能被整除，立即跳出内层循环
end=" "：使输出在同一行以空格分隔

优化建议

可以只判断奇数（除了2以外）
使用埃拉托斯特尼筛法（Sieve of Eratosthenes）能更高效地找出质数

扩展练习

尝试使用 while 循环实现质数判断
尝试使用函数封装质数判断逻辑
尝试输出 n 以内的所有合数（非质数）

AI 生成的详解

Python 控制流详解

一、分支结构深入

1.1 条件表达式

Python 使用布尔值（True/False）作为判断条件：

# 比较运算符
a = 10
b = 5
print(a > b)   # True
print(a == b)  # False
print(a != b)  # True

1.2 if 语句的完整结构

# 完整的 if-elif-else 结构
score = int(input("请输入你的分数："))

if score >= 90:
    grade = "A"
    print("优秀！")
elif score >= 80:
    grade = "B"
    print("良好！")
elif score >= 70:
    grade = "C"
    print("中等！")
elif score >= 60:
    grade = "D"
    print("及格！")
else:
    grade = "F"
    print("不及格，需要努力！")

print(f"你的等级是：{grade}")

1.3 嵌套 if 语句

age = int(input("请输入你的年龄："))
has_license = input("你有驾照吗？(yes/no): ").lower()

if age >= 18:
    if has_license == "yes":
        print("你可以开车上路！")
    else:
        print("你需要先考取驾照！")
else:
    print("你还未成年，不能开车！")

1.4 逻辑运算符

# and（与）、or（或）、not（非）
age = 20
is_student = True
has_ticket = False

if age >= 18 and is_student:
    print("可以享受学生优惠！")

if has_ticket or age < 12:
    print("可以进入！")

if not has_ticket:
    print("需要购票！")

二、循环结构深入

2.1 while 循环详解

# 基本 while 循环
count = 1
while count <= 5:
    print(f"这是第 {count} 次循环")
    count += 1  # 重要：不要忘记改变条件变量！

# 无限循环与 break
total = 0
while True:  # 无限循环
    num = input("请输入数字（输入'q'退出）：")
    if num == 'q':
        break  # 跳出循环
    total += int(num)
print(f"总和为：{total}")

# continue 的使用
num = 0
while num < 10:
    num += 1
    if num % 2 == 0:
        continue  # 跳过偶数
    print(num)

2.2 for 循环详解

# 遍历列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

# 遍历字符串
message = "Hello Python"
for char in message:
    print(char)

# range() 函数详解
print("range(5):", list(range(5)))      # [0, 1, 2, 3, 4]
print("range(2, 7):", list(range(2, 7))) # [2, 3, 4, 5, 6]
print("range(1, 10, 2):", list(range(1, 10, 2))) # [1, 3, 5, 7, 9]

# 反向遍历
for i in range(10, 0, -1):
    print(i, end=" ")  # 10 9 8 7 6 5 4 3 2 1

2.3 循环的 else 子句

# for-else：当循环正常完成（未被break中断）时执行else
for i in range(5):
    if i == 10:  # 这个条件永远不会满足
        break
    print(i)
else:
    print("循环正常完成！")

# while-else 类似
count = 0
while count < 5:
    print(count)
    count += 1
else:
    print("while循环正常结束")

2.4 嵌套循环

# 打印乘法表
print("九九乘法表：")
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j:2d}", end="  ")
    print()  # 换行

三、质数判断程序的优化与扩展

3.1 优化版本 - 使用函数封装

def is_prime(num):
    """判断一个数是否为质数"""
    if num <= 1:
        return False
    if num == 2:
        return True
    if num % 2 == 0:
        return False

    # 只检查奇数因子
    for i in range(3, int(num ** 0.5) + 1, 2):
        if num % i == 0:
            return False
    return True

def find_primes(n):
    """找出1到n中的所有质数"""
    primes = []
    if n >= 2:
        primes.append(2)

    # 只检查奇数
    for num in range(3, n + 1, 2):
        if is_prime(num):
            primes.append(num)

    return primes

# 主程序
n = int(input("请输入一个整数 n："))
primes = find_primes(n)
print(f"1 到 {n} 中的所有质数：{primes}")
print(f"共有 {len(primes)} 个质数")

3.2 高级版本 - 埃拉托斯特尼筛法

def sieve_of_eratosthenes(n):
    """使用筛法找出所有质数"""
    if n < 2:
        return []

    # 创建标记数组，初始假设所有数都是质数
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False

    for i in range(2, int(n ** 0.5) + 1):
        if is_prime[i]:
            # 将i的倍数标记为非质数
            for j in range(i * i, n + 1, i):
                is_prime[j] = False

    # 收集所有质数
    primes = [i for i in range(2, n + 1) if is_prime[i]]
    return primes

# 测试筛法
n = int(input("请输入一个整数 n："))
primes = sieve_of_eratosthenes(n)
print(f"1 到 {n} 中的所有质数：")
for i, prime in enumerate(primes, 1):
    print(f"{prime:4d}", end=" ")
    if i % 10 == 0:  # 每行显示10个
        print()

3.3 扩展练习 - 质数分解

def prime_factors(num):
    """分解质因数"""
    factors = []
    divisor = 2

    while divisor * divisor <= num:
        if num % divisor == 0:
            factors.append(divisor)
            num //= divisor
        else:
            divisor += 1 if divisor == 2 else 2  # 跳过偶数

    if num > 1:
        factors.append(num)

    return factors

# 测试质因数分解
number = int(input("请输入一个正整数："))
factors = prime_factors(number)
print(f"{number} = ", end="")
print(" × ".join(map(str, factors)))

四、综合练习

4.1 猜数字游戏

import random

def guess_number():
    """猜数字游戏"""
    secret = random.randint(1, 100)
    attempts = 0
    max_attempts = 10

    print("猜数字游戏开始！我有一个1-100之间的秘密数字。")

    while attempts < max_attempts:
        try:
            guess = int(input(f"第{attempts+1}次尝试，请输入你的猜测："))
        except ValueError:
            print("请输入有效的数字！")
            continue

        attempts += 1

        if guess < secret:
            print("太小了！")
        elif guess > secret:
            print("太大了！")
        else:
            print(f"恭喜！你在{attempts}次内猜对了！")
            break

    if attempts >= max_attempts:
        print(f"游戏结束！正确答案是：{secret}")

# 运行游戏
guess_number()

4.2 计算器程序

def calculator():
    """简单的计算器"""
    print("简单计算器")
    print("支持的操作：+ - * / % **")
    print("输入 'quit' 退出")

    while True:
        expression = input("\n请输入表达式：").strip()

        if expression.lower() == 'quit':
            print("再见！")
            break

        try:
            result = eval(expression)  # 注意：eval有安全风险，这里仅用于示例
            print(f"结果：{result}")
        except ZeroDivisionError:
            print("错误：不能除以零！")
        except:
            print("错误：无效的表达式！")

# 更安全的版本
def safe_calculator():
    """更安全的计算器版本"""
    while True:
        print("\n1. 加法")
        print("2. 减法")
        print("3. 乘法")
        print("4. 除法")
        print("5. 退出")

        choice = input("请选择操作：")

        if choice == '5':
            break

        if choice not in ['1', '2', '3', '4']:
            print("无效的选择！")
            continue

        try:
            num1 = float(input("请输入第一个数："))
            num2 = float(input("请输入第二个数："))

            if choice == '1':
                result = num1 + num2
                operator = "+"
            elif choice == '2':
                result = num1 - num2
                operator = "-"
            elif choice == '3':
                result = num1 * num2
                operator = "*"
            elif choice == '4':
                if num2 == 0:
                    print("错误：除数不能为零！")
                    continue
                result = num1 / num2
                operator = "/"

            print(f"{num1} {operator} {num2} = {result}")

        except ValueError:
            print("请输入有效的数字！")

五、学习建议

5.1 调试技巧

使用 print 调试：在关键位置打印变量值
使用断点：在 VS Code 中设置断点
异常处理：使用 try-except 捕获错误

5.2 编程习惯

变量命名：使用有意义的变量名
注释：为复杂逻辑添加注释
函数封装：将重复代码封装成函数
测试：为代码编写测试用例

5.3 进阶学习

列表推导式：简化循环创建列表
生成器：处理大数据时节省内存
装饰器：扩展函数功能
面向对象编程：类和对象的概念

六、实践任务

完成以下编程任务来巩固学习：

任务1：斐波那契数列

编写程序输出前 n 个斐波那契数列

任务2：闰年判断

输入年份，判断是否为闰年

任务3：最大公约数和最小公倍数

输入两个数，计算它们的最大公约数和最小公倍数

任务4：回文数判断

判断一个数是否为回文数

Python入门 #1

Mon, 17 Nov 2025 11:20:41 GMT

第一个程序

注意：不一定所有内容都能看得懂，实践最重要。所以遇到不懂得可以先跳过（或者直接问），写的代码多了就懂了。

如何打开IDE呢？下载好Python安装后可以在桌面上发现一个名叫IDLE的快捷方式（如果在安装时选择了创建快捷方式），点击即可打开。由于机房电脑一些奇奇怪怪的错误，学校机房的桌面快捷方式死了，所以请按下Win键（或点击左下角Windows图标）打开开始菜单查找Python->IDLE打开。建议选择白色的。

IDE: IDE是集成开发环境的缩写，可以大致理解为用于进行开发活动的全套软件。

交互式解释器介绍

刚打开IDLE时，你会发现一个白色的窗口，其中有如下字样：

Python 3.4.0 (v3.4.0:04f714765c13, Mar 16 2014, 19:24:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

最后一行前的>>> 标志这是交互式解释器。交互式就意味输入一行解释器就会执行一行。例如：

>>> 12+13
25
>>> 135465457654357654357356**10
2081065193176208652493570136210529355534687343561794797850624650869897720865652351060577643074271139111678336606170815459838610973844137190397334937575949673593026866575900058843430712604593435740147956665499607587584231896358322176

其中，你若输入一个表达式，他就会返回表达式的值；反若是语句等，则输出结果。例如print是一个函数：

>>> print
<built-in function print>

直接输入（即当做表达式输入）返回的是其类型（即值）：内建函数print

表达式：蕴含值的一个式子（大致可如此理解）。例如，1+1是一个表达式，1234*4537也是一个表达式

print函数： print函数用于把参数向控制台输出。例如：
>>> print(12)
12

实践

打开IDLE，使用交互式解释器在控制台输出hello, world!

在文件中写代码

点击窗口左上角的File，选择New File，就可以打开一个名叫untitled的文件编辑窗口。你可以在这里写代码保存到文件并执行。

例如，输入：

print(1+1)

按Ctrl+S保存，输入你想取的名字，保存在合适位置。

接着，点击Run，选择Run model，即可在刚才打开的交互式解释器查看运行结果。例如刚才的文件的运行结果是：

>>> ================================ RESTART ================================
>>>
2

实践

创建一个名叫helloworld.py(需要把显示拓展名打开)的文件，编辑合适的代码，使得这个文件能够向控制台输出hello, world。

# P6824 🉑乐题解

Thu, 23 Oct 2025 18:49:57 GMT

🉑乐题解

参考题解：题解 P6824 【「EZEC-4」可乐】

题目分析

有 n 瓶可乐，每瓶可乐有一个口味值 a[i]（非负整数）。
你可以选择一个整数 x（非负整数），对于每瓶可乐：
- 如果 (a[i] XOR x) <= k，那么你能喝到这瓶可乐。
目标：选择合适的 x，使得能喝到的可乐瓶数最多，输出这个最大值。

解题思路

暴力做法

最直接的想法是枚举所有可能的 x，然后对每个 x 统计有多少瓶可乐满足 (a[i] XOR x) <= k。

但是 x 的范围是多少呢？因为 2^a[i] < 2^21，所以 a[i] 最大可能接近 2^21，但 x 的值其实可以限制在 [0, 2^21)，因为更大的 x 只是高位不同，对比较结果影响不大，而且 k 最大也是 2^21 级别，所以枚举到 2^21 就足够了。

优化思路

我们知道，从暴力法求解主要需要两个步骤：

枚举可能的x
对于给定的 x，计算有多少 a[i] 满足 (a[i] XOR x) <= k

我们打算使用 Trie 树（二进制 Trie，这样就只用跑）来存储所有 a[i]，并在 Trie 上沿着 x XOR k 的路径走，同时统计满足条件的节点数量。

查询

在Trie上，我们从高位到低位枚举，

记：k的第i位为1，x的第i位为c，假设前面判断的每一位都相等：

如果k的这一位是1，那么a[i] XOR x在这一位为0的所有情况都满足条件。

因为高位相等，当前位0 < 1，所以整个子树都满足(a[i] XOR x) < k

        if (t == 1) {
            // 如果k的这一位是1，那么a[i] XOR x在这一位为0的所有情况都满足条件
            // 因为高位相等，当前位0 < 1，所以整个子树都满足(a[i] XOR x) < k
            ret += sz[trie[p][!(c ^ t)]];
        }

k的当前位为0：

此时：(a[i] XOR x) 的当前位必须是 0
- 如果是 1：那么 (a[i] XOR x) > k，不满足条件
- 如果是 0：继续判断低位
代码实现：只能沿着c ^ t方向继续走。
```
        if (!trie[p][c ^ t]) {
            flag = 1;  // 标记提前结束
            break;
        }
        p = trie[p][c ^ t];  // 移动到下一个节点
```

注意：如果没有提前结束（即最后一个节点亦可），记得加上最后相等的情况。

if (!flag) ret += sz[p];

统计 (a[i] XOR x) == k 的情况。

Open Source: The Hacker's Utopia

Mon, 20 Oct 2025 10:42:03 GMT

Open Source: The Hacker's Utopia

Hello everyone, it's a great honor to stand here and share my topic with you. Firstly, I'd like to ask you all to guess what I'll be talking about today.

(In English)

Initially, I intended to address the issue of wasteful electricity consumption and its environmental impact. However, assuming this topic might not resonate with everyone, I've decided to pivot to an alternative subject.

Lately I have been deeply attracted by open-source software. I think it has some characteristics of communism.Generally speaking, my speech today has four parts.

Let's begin!

First: The Hook: "The $0 Operating System That Powers the World"

Have you ever used a phone?

Have you ever surfed the internet?

Did you know that ALMOST 90% of the servers you rely on are running on the FREE, OPEN-SOURCE operating system, Linux?

The system of almost every phone is Android, which is based on the Linux kernel.

Furthermore, did you know that ALMOST 70% of the servers you rely on are running on the FREE, OPEN-SOURCE operating system, Linux?

What is Linux? A free, open-source, and community-driven operating system that powers the world.

The Core Idea: Freedom

Open Source: Anyone can view, use, and contribute to its code.
Free: Most distributions are free of cost.

Where is it

"Many people think of Linux as a niche technical tool, but the reality is, it's the invisible foundation of our digital world. It's everywhere, powering everything from the vast internet to the devices in our pockets. Let me show you what I mean."

🌐 The Internet:
- "Look at the internet. Over 70% of all web servers run on Linux. What this means is that virtually every website you visit is most likely delivered to you by a machine running Linux. It's the bedrock of the online experience."
📱 Android:
- "Now, think about your phone. Android is the world's most popular mobile OS, and it's built directly on top of the Linux kernel. So, if you use an Android phone, you are using a Linux-based system every single day. "
💻 The Cloud:
- "Moving to the cloud. Linux powers the vast majority of cloud infrastructure. Whether it's Amazon AWS, Google Cloud, or Microsoft Azure, the cloud, quite literally, runs on Linux. It's the engine of the modern digital economy."
🖥️ Supercomputers:
- "For the most demanding tasks. When scientists need to tackle the world's biggest problems—like climate modeling or genetic research—they turn to supercomputers. And nearly all of them run on Linux, proving its unmatched power and reliability ."
🔧 Your Car & Smart Devices:
- "And it's even closer to home. Linux is embedded in the technology all around us: in our cars, our home routers, and our smart gadgets. This shows its incredible versatility and adaptability ."

"So, from the global scale of the internet and the cloud, down to the personal devices we interact with constantly, Linux is the silent, stable, and powerful force that makes it all work. It truly is the unsung hero of our connected world."

So for the normal person, what is the meaning of Open-Source?

Security: The source code is open for inspection by anyone, which allows vulnerabilities to be found and fixed quickly by the global community.
Reliability & Quality: Peer review by a large number of developers often leads to more stable, efficient, and high-quality software.
Flexibility & Customization: Users have the freedom to modify the code to fit their specific needs and requirements.
Active Community Support: Vibrant communities provide free support, documentation, tutorials, and continuous improvement.

Well, there are always some disadvantage, such as:

Lack of Official Support: While community support is available, there may be no formal support service or guaranteed response time, which can be a risk for businesses.
Complexity & Usability: Some open-source software may have a steeper learning curve and less polished user interface compared to commercial products.
Potential Security Risks: While transparency aids security, it also means hackers can equally study the code to find vulnerabilities before they are patched.

But honestly, these downsides aren't a big deal. That's because we have a global community of dedicated open-source developers who are driven by passion and a spirit of collaboration.

But generally speaking, the most compelling aspect of the open-source model is its profound spirit of contribution. Countless developers, driven by pure passion and altruism, dedicate their talents and valuable time without monetary reward. They collaborate to build powerful software, motivated not by profit, but by the belief that through selfless sharing, they can make the world of technology better for everyone.

What is Open Source? Beyond "Free as in Beer"

Open-source software is the closest thing we have to the communist ideal in the digital age.

Abolition of Private Property: Source code is the "means of production," rendered public property by its license.

From Each According to Ability: Developers contribute voluntarily, following their own interests and skills.

To Each According to Need: Any open-source software is free for any person to use for any need.

You can see them commit their latest changes, as recently as 2 days ago, not for profit, but for passion.

You can see thousands of individuals, bound by a shared passion, converge into a single force.

Finally, I'd like to end with an emphatic sentence: It is their dedication and selfless sharing that makes the open-source truly strong, has allowed me to truly appreciate the charm of open source.

Linux终端使用帮助

Sat, 04 Oct 2025 22:17:10 GMT

终端使用帮助

在Linux下，终端是一定需要掌握的工具。它可以直接与任何安装在系统上的软件进行交互（包括系统底层（直接或通过软件）），并可以执行许多在图形化界面不能完成的操作，因为Linux最初就只有一个终端（绝大多数来电脑皆是这样的，包括Windows的老祖宗）

常用命令一览

sudo - 提升权限

Pay Attantion!!!!!

We trust you have received the usual lecture from the local System Administrator. It usually boils down to these three things:

#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.

[sudo] password for [用户名]:

这是第一次运行sudo时的提示。很抱歉这一次被我使用掉了。但是你们也必须知道这一点。sudo是提升用户权限为管理员的指令，使用后的10min用户都可以显式地获得临时的管理员权限（如用于安装软件等）。
注意：sudo命令后的输入密码环节**密码不回显！**即没有*提示（可以配置但是没有必要）

上面那段话的翻译：

我们相信您已从当地系统那里听到了常规的训诫管理员。通常归结为以下三点： #1) 尊重他人的隐私。 #2）三思而后行。 #3) 力量越大，责任越大。 [sudo] 用户名的密码：

`chmod`：权限管理之一

常用参数：

-x：添加执行权限。

同样的也有-x：取消执行权限

例如：

djy@DianJiaoYuan:~/Temp$ cat temp.sh
#!/usr/bin/bash
echo "HelloWorld"

djy@DianJiaoYuan:~/Temp$ ll temp.sh
-rw-rw-r-- 1 djy djy 35 10月  4 22:10 temp.sh
djy@DianJiaoYuan:~/Temp$ ./temp.sh
bash: ./temp.sh: 权限不够
djy@DianJiaoYuan:~/Temp$ chmod +x temp.sh
djy@DianJiaoYuan:~/Temp$ ./temp.sh
HelloWorld
djy@DianJiaoYuan:~/Temp$ ll temp.sh
-rwxrwxr-x 1 djy djy 35 10月  4 22:10 temp.sh*
djy@DianJiaoYuan:~/Temp$ chmod -x temp.sh
djy@DianJiaoYuan:~/Temp$ ./temp.sh
bash: ./temp.sh: 权限不够
djy@DianJiaoYuan:~/Temp$ ll temp.sh
-rw-rw-r-- 1 djy djy 35 10月  4 22:10 temp.sh
djy@DianJiaoYuan:~/Temp$

mkdir touch

mkdir: 创建目录

touch: 创建文件

echo

输出

$ echo "Hello, World!"
"Hello, World!"
$

ls

ls命令用于列出目录中的所有文件及子目录。有几个常用的参数：

-a：列出隐藏文件，默认有缩写la
-l：列出详细信息，默认有缩写ll

cat

输出文件内容

例如：

$ cat temp.txt
Exemple File

pwd

cd

进入某目录例：

djy@DianJiaoYuan:~$ cd 下载
djy@DianJiaoYuan:~/下载$ pwd
/home/djy/下载

rm 删除文件/目录

rm <filename>删除文件<filename>

djy@DianJiaoYuan:~/Temp$ touch temp.txt
djy@DianJiaoYuan:~/Temp$ ls
temp.txt
djy@DianJiaoYuan:~/Temp$ rm temp.txt
djy@DianJiaoYuan:~/Temp$ ls
djy@DianJiaoYuan:~/Temp$

辅助字符（部分常用的）

`&&`

连续执行（在前者执行成功之后）如

djy@DianJiaoYuan:~$ mkdir Temp && cd Temp
djy@DianJiaoYuan:~/Temp$ pwd
/home/djy/Temp

`>` / `>>`

>: 覆写。即删除文件所有内容并写入(执行过程：若存在同名文件：覆盖；不存在：创建。所以会自动创建文件)
>>: 追加。即在文件最后追加内容(同样会自动创建文件（兼容性存疑））

djy@DianJiaoYuan:~/Temp$ touch temp.txt
djy@DianJiaoYuan:~/Temp$ ls
temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
djy@DianJiaoYuan:~/Temp$ echo "Hello, world!" > temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
Hello, world!
djy@DianJiaoYuan:~/Temp$ echo "Hello, Linux!" > temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
Hello, Linux!
djy@DianJiaoYuan:~/Temp$ echo "Hello, Linux!" >> temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
Hello, Linux!
Hello, Linux!
djy@DianJiaoYuan:~/Temp$ rm temp.txt
djy@DianJiaoYuan:~/Temp$ ls
djy@DianJiaoYuan:~/Temp$ echo "Hello, world!" > temp.txt
djy@DianJiaoYuan:~/Temp$ ls
temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
Hello, world!
djy@DianJiaoYuan:~/Temp$ rm temp.txt
djy@DianJiaoYuan:~/Temp$ ls
djy@DianJiaoYuan:~/Temp$ echo "Hello, World!" >> temp.txt
djy@DianJiaoYuan:~/Temp$ ls
temp.txt
djy@DianJiaoYuan:~/Temp$ cat temp.txt
Hello, World!

`|`管道字符。

将前者的输出作为后者的输入执行两者（将前者的标准输出(stdout)重定向到后者的标准输入stdin）。

例如：

djy@DianJiaoYuan:~/Temp$ echo "#include <bits/stdc++.h>
int main() {
    int a;
    std::cin >> a;
    std::cout << \"a = \" << a << std::endl;
    return 0;
}" > temp.cpp
djy@DianJiaoYuan:~/Temp$ g++ -std=c++14 -O2 -o temp temp.cpp
djy@DianJiaoYuan:~/Temp$ ./temp
1
a = 1
djy@DianJiaoYuan:~/Temp$ echo "12" > ./temp
djy@DianJiaoYuan:~/Temp$ echo "#include <bits/stdc++.h>
int main() {
    int a;
    std::cin >> a;
    std::cout << \"a = \" << a << std::endl;
    return 0;
}" > temp.cpp
djy@DianJiaoYuan:~/Temp$ g++ -std=c++14 -O2 -o temp temp.cpp
djy@DianJiaoYuan:~/Temp$ echo "1" | ./temp
a = 1
djy@DianJiaoYuan:~/Temp$ echo "1" > ./temp
djy@DianJiaoYuan:~/Temp$ ./temp
./temp: 行 1: 1：未找到命令
djy@DianJiaoYuan:~/Temp$ cat ./temp
1

这个用处还是挺多的，可以直接把cat 文件作为前项，达到不用手输输入。或者这个好玩的（需要你们自己试试，我这里就放终端复制的HTML了）

<pre>djy@DianJiaoYuan:~$ ll | lolcat 总用量 72 drwxr-xr-x 12 djy djy 4096 10月 3 23:20 ./ drwxr-xr-x 3 root root 4096 10月 3 21:52 ../ drwxr-xr-x 2 djy djy 4096 10月 3 22:37 下载/ drwxr-xr-x 2 djy djy 4096 10月 3 22:44 桌面/ -rw------- 1 djy djy 15 10月 3 21:57 .bashhistory -rw-r--r-- 1 djy djy 220 10月 3 21:52 .bash_logout -rw-r--r-- 1 djy djy 3771 10月 3 21:52 .bashrc drwx------ 14 djy djy 4096 10月 4 2025 .cache/ drwxr-xr-x 12 djy djy 4096 10月 3 22:03 .config/ drwx------ 3 djy djy 4096 10月 3 21:52 .dbus/ drwx------ 3 djy djy 4096 10月 4 2025 .gnupg/ drwx------ 3 djy djy 4096 10月 4 2025 .local/ drwx------ 5 djy djy 4096 10月 4 2025 .mozilla/ -rw-r--r-- 1 djy djy 807 10月 3 21:52 .profile -rw-r--r-- 1 djy djy 0 10月 3 22:37 .sudoas_admin_successful drwxrwxr-x 2 djy djy 4096 10月 3 23:35 Temp/ -rw------- 1 djy djy 4138 10月 3 22:44 .viminfo drwxr-xr-x 3 djy djy 4096 10月 3 21:52 .vscode/ </pre>

第三方常用软件

g++

这里介绍g++的常用用法

g++ "文件名" <选项> 常用的选项有：

-o 指定输出文件名
-std=指定C++标准。如C++ 14

lolcat: 彩色输出

例如：

djy@DianJiaoYuan:~$ ls | lolcat
001.cpp
下载
桌面
clash-for-linux
OI-ZhX589
temp
Temp
temp.cpp
temp.o

当然，实际上要你们自行测试才能清楚是什么样子的（或者使用typora打开时查看上面那一段HTML代码）。

树链剖分

Thu, 25 Sep 2025 18:54:00 GMT

树链剖分

重链剖分

树链剖分：将树分割成若干条链的形式，用于维护树上的信息。

形式：

重链剖分
长链剖分
实链剖分
等等

重链剖分由于将树上数据的维护变成了序列数据的维护，因此可以用线段树等维护序列的数据结构便捷地维护。

定义申明

重儿子（Heavy Son）：对于一个节点 u，其所有子节点中子树大小最大的那个子节点称为重儿子。如果有多个最大，任意选一个。
轻儿子（Light Son）：除了重儿子以外的其他子节点。
重边（Heavy Edge）：连接节点 u 和其重儿子的边。
轻边（Light Edge）：连接节点 u 和其轻儿子的边。
重链（Heavy Chain）：由一系列重边连接而成的路径。重链的开头是轻儿子或根节点。

需要为每个节点 u 存储的信息：

father[u]：节点 u 的父节点。
deep[u]：节点 u 的深度（根节点深度为0或1）。
sz[u]：以 u 为根的子树的节点数量。
son[u]：节点 u 的重儿子。
top[u]：节点 u 所在重链的顶端节点。
tid[u]（或 id[u]）：节点 u 在 DFS 序（新编号） 中的位置。
wt[dfn[u]]：DFS 序对应位置的节点权值。

把落单的结点也当作重链，那么整棵树就被剖分成若干条重链。如图：

来源于OI-WiKi，侵删

注意：

节点编号有：

原编号（节点ID）
- 范围：1 到 n
- 用途：x, fa, edge[i].to 等都使用这个编号体系
- 示例：根节点是1，它的子节点可能是2,3,4等
DFS序编号 (tid)
- 范围：1 到 n
- 用途：线段树中的位置编号
- 映射：tid[x] 表示原节点x的DFS序位置
边的索引 (edge下标)
- 范围：1 到 cnt（边的计数器）
- 用途：邻接表中遍历边时使用

实现

共用两个DFS：

信息收集

目的： 计算每个节点的基础信息，为后续剖分做准备。

获得了以下基础信息：

每棵树的子树大小
标记父节点和深度
确定重儿子

具体步骤：

void dfs1(int x, int fa, int depth) // 节点id，fa id，节点在树上的深度；
{
    sz[x] = 1; // 初始化节点子树大小
    father[x] = fa;
    deep[x] = depth; // 节点在树上的深度

   	// 遍历该节点的所有子节点(链式前向星)
    for (int i = head[x]; i; i = edge[i].next) // i是指针
    {
        Node v = edge[i].to;
        if (v == fa) continue; // 非有向边

        dfs1(v, x, depth+1);
        sz[x] += sz[v];

        // 判断重儿子 <- 没有重儿子/新节点更重
        if (!son[x] or sz[v] > deep[son[x]])
            son[x] = v;
    }
}

划分重链并生成DFS序

核心逻辑:

DFS序分配 (tid[])
- 每个节点被访问时获得一个唯一的DFS序编号
- 关键技巧：先递归重儿子，保证同一条重链上的节点编号连续
重链划分 (top[])
- tp 参数表示当前重链的顶端节点
- 重儿子继承父亲的链顶 (dfs2(son[x], tp))
- 轻儿子自己成为新链的顶端 (dfs2(轻儿子, 轻儿子))

具体步骤：

void dfs2(int x, int tp)
{
    tid[x] = ++tidnum;
    pos[tid[x]] = x; // 反向映射，用于通过DFS序来查找节点
    top[x] = tp; // 标记链顶

    // 叶子节点特判
    if (!son[x]) return;
    dfs2(son[x], tp); // 先对重儿子进行DFS保证DFS序的顺序

    // 对轻节点进行遍历：
    // - 遍历所有节点
    // - 判断是否是重节点：
    // ├── 不是：DFS并以它本身作为链顶
    // └── 是：跳过
    for (int i = head[x]; i; i = edge[x].next)
    {
        int v = edge[i].to;
        if (v != son[x] and v != father[x]) // 注意：无向边需特判父节点
        {
           	dfs2(v, v);
        }
    }
}

附：链式前行星代码

// 链式前向星
struct Node {
    int to, next;
//  int w; //权重
} edge[maxn << 2]; // 边翻四倍

addedge(int u, int v)
{
    edge[++cnt] = {v, head[u]};
    head[u] = cnt;
}

Linux入门：安装系统

Mon, 25 Aug 2025 17:21:31 GMT

Linux系统的安装

1. 系统的选择

Linux发展了几十年，到今天已经诞生了上百种发行版我个人建议新手使用Ubnutu系的发行版（或debian系），软件源十分丰富，而且入手难度低；

当然，国产系统也是不错的选择，比如Deppin、统信USO

这里以Ubuntu系的LinuxMint为例来演示，这也是我现在正在使用的发行版。

下载ISO镜像文件

访问LinuxMint官网（或其他发行版官网）下载ISO系统镜像，里面有很多镜像地址，如alibaba的。

制作启动盘

目前启动盘制作主要可以用以下几种方法（都要准备一个至少8G的U盘）：

方法1：将文件写入U盘中

优点：~~历史悠久~~，稳定；缺点：每次制作都要格式化U盘，且只能同时制作1张

方法2：使用Ventoy

Ventoy只需要在U盘中放入镜像文件（放进去就行）即可作为启动盘，可以一次放入多个系统镜像，也可以放入杂七杂八的文件。~~建议使用64G以上的U盘（最低8G不影响）因为以后你可能像我一样放七八个镜像文件、一包安装包和一堆备份文件~~

注意：请确保U盘容量正常不虚标，否则制作将失败

首先前往官网下载相应系统最新版本的Ventoy，插入U盘，正对电脑启动方式选择对应的分区类型。

简单来说，你无法在MBR磁盘上安装UEFI模式的操作系统，也无法在GPT磁盘上安装传统的BIOS模式操作系统。

所以如果待重装系统的电脑是UEFI模式，则需要选择GPT类型，反之则选择MBR类型。

一般来讲，新电脑一般是UEFI模式的。

插入U盘后

在设备中选择到你的U盘，点击安装（确认U盘内没有重要文件），就会格式化U盘并安装Ventoy到你的U盘上。此时会创建两个分区，

其中Ventoy用于放置你的ISO文件或其他需要存储的文件，VTOYEFI则是引导电脑寻找文件的分区。安装好并放入刚才下载的ISO文件后，重启电脑至启动设备菜单（需要按下特殊按键。

常见的按键有哪些？（需要快速连按）

最常见的是 F12 和 Esc

华硕 (ASUS)：F8

技嘉 (GIGABYTE)：F12

微星 (MSI)：F11

联想 (Lenovo)：F12 或笔记本侧的 Novo键

戴尔 (Dell)：F12

惠普 (HP)：F9 或 Esc

宏碁 (Acer)：F12

三星 (Samsung)：Esc 或 F2、F10

Surface：按住 音量减键 再按一下电源键

随后选择通过你的U盘启动。随后你会打开一个体验LinuxMint的界面，双击运行桌面上的引导程序，你就可以根据提示与选项安装系统了。

注意：

安装后可能出现无法联网的现象，这是因为驱动缺失，建议使用网线/蓝牙先暂时连接网络，等按照欢迎画面的提示把

驱动和软件更新安装好就行了

常用软件推荐：

首先可以安装QQ和微信，使用Firefox搜索进入官网下载即可。建议下载AppImage包，这个给到运行后即可直接使用，卸载只需将该文件删除；

# 进入下载目录
cd Downloads/
# 授予执行权限
chmod +x QQ_*.AppImage # 换成实际文件名
# 或者使用通配符
chmod +x *.AppImage

或下载.deb安装包

# 建议使用apt安装，避免依赖问题
sudo apt install ./QQ_*.deb # 一定要加上`./`，告诉apt于本地寻找文件而非在线查找
# 或者使用dpkg，最原始的方式
sudo dpkg -i QQ_*.deb # `./`加不加皆可

其他系统自行搜索教程

其他生产力工具：

markdown编辑器：Typora

sudo apt install typora

代码编辑器：sublime text

sudo apt install sublime-text

修图软件：GIMP（Linux上的PS）

sudo apt install gimp

游戏推荐

**经典中的经典：**steam

sudo apt install steam

吉祥物Tux：

sudo apt install supertux
sudo apt install supertuxkart
sudo apt install extremetuxracer

**开元RTS：**Warzone2100

sudo apt install warzone2100

剩下的你们就自行探索啦！

入门：C++的位运算

Mon, 25 Aug 2025 15:03:09 GMT

Ｃ++的位运算

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

Ｃ++中有6种位运算符：

&: 与

1 & 1 = 1

1 & 0 = 0

0 & 0 = 0
|: 或

1 | 1 = 1

1 | 0 = 1

0 | 0 = 0
~: 非

~ 1 = 0

~ 0 = 1
^: 异或

1 ^ 1 = 1

1 ^ 0 = 0

0 ^ 0 = 1
<<: 左移

$1 << 1 = 10_２$

$1 << 2 = 100_2$
>>: 右移

$11_2 >> 1 = 110_2$

入门：链表

Mon, 25 Aug 2025 15:00:34 GMT

链表

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

链表是一种动态的数据结构，每一个节点存储两个数据：data和next。data是数据，next是下一个节点的地址。

链表经常是首尾相接的。

算法竞赛中，链表常用STL 中的list而非手写，以节约时间。

这里给到Luogu P1996的题解示范list的用法。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, m;  cin >> n >> m;
    list<int> node;

    for (int i = 1; i <= n; ++i) node.push_back(i); // 建立列表
    list<int>::iterator it = node.begin(); // 创建迭代器
    while (node.size() > 1) {
        for (int i = 1; i < m; i++) {
            it++;
            if (it == node.end()) it = node.begin();
        }
        cout << *it << " ";
        list<int>::iterator next = ++it;
        if (next == node.end()) next = node.begin();
        node.erase(--it);
        it = next;
    }
    cout << *it;
    return 0;
}

C++中二叉树的前序、中序、后序、层序遍历

Sun, 24 Aug 2025 19:36:00 GMT

二叉树的遍历

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

什么是二叉树

二叉树是一个为空或者由不相交的左子树、右子树和根节点组成的集合。其中左右子树也为二叉树。

例如，这是一个二叉树：

flowchart TD
    A[A] --> B[B]
    A --> C[C]
    B --> D[D]
    B --> E[E]
    C --> F[F]
    C --> G[ ]
    style G fill:none, stroke:none

而这也是一个二叉树（已经退化成一条链了）：

flowchart TD
A[1] --> B[2]
A --> None1[ ]
B --> C[3]
B --> None2[ ]
C --> D[4]
C --> None3[ ]
style None1 fill: none, stroke: none
style None2 fill: none, stroke: none
style None3 fill: none, stroke: none

左右子树为空集节点叫做叶子节点。

每一层被填满的二叉树叫做完美二叉树（满二叉树）。按照从上到下、从左到右的顺序编号，只有最后一层缺失、且缺失的编号都在最后在的二叉树叫做完全二叉树。

如何存储

(1 动态存储

数据结构中一般这样定义二叉树：

struct Node {
	int value; // 节点的值，可以不止一个
    node *lson, *rson; // 指向左右子节点
}

动态新建一个Node时，使用new运算符动态申请一个。使用完毕记得使用delete命令释放防止内存泄漏。

动态二叉树的优点是不浪费空间，缺点是需要管理，容易出错。

(2 使用静态数组存储

比赛中一般使用这种方法，编码比较简单。

struct Node {
    int value;
    int lson, rson; // 子节点在数组中的编号
} tree[N];

特别地，可以使用单独的一个静态数组实现完全二叉树的存储。

二叉树的各种遍历

常见遍历二叉树的方式有一下几种，我以以下树展示

flowchart TD
1 --> 2
1 --> 3
2 --> 4
2 --> 5
3 --> 6
3 --> 01[ ]
4 --> 7
4 --> 8
5 --> 02[ ]
5 --> 9
style 01 fill: none
style 02 fill: none

先序遍历

按照根节点 -> 左子树 -> 右子树的顺序遍历。这颗树的先序遍历是1 2 4 7 8 5 9 3 6

void preorder(Node root) {
    cout << root.value << ' ';
    if (root.lson)
	    preorder(tree[root.lson]);
    if (root.rson)
	    preorder(tree[root.rson]);
}

中序遍历

按照左子树 -> 根节点 -> 右子树的顺序遍历。这颗树的中序遍历是7 4 8 2 5 9 1 6 3

void inorder(Node root) {
    if (root.lson)
	    inorder(tree[root.lson]);
    cout << root.value << ' ';
    if (root.rson)
	    inorder(tree[root.rson]);
}

后序遍历

按照左子树 -> 右子树 -> 根节点的顺序遍历。这颗树的后序遍历是7 8 4 9 5 2 6 3 1

void postorder(Node root) {
    if (root.lson)
	    postorder(tree[root.lson]);
    if (root.rson)
	    postorder(tree[root.rson]);
    cout << root.value << ' ';
}

层序遍历

顾名思义，层序遍历即从上到下一层一层地遍历节点。

前面集中遍历方式都使用的DFS（深度优先搜索），层序遍历建议使用BFS（广度优先搜索）。

这颗树的层序遍历是1 2 3 4 5 6 7 8 9

void bfs(Node root) {
    queue<Node> Q;
    Q.push(root);

    while (!Q.empty()) {
        Node node = Q.front();
        Q.pop();
        cout << node.value << ' ';

        if (node.lson)
            Q.push(tree[node.lson]);
        if (node.rson)
            Q.push(tree[node.rson]);
    }
}

总结一下，可以是这样的：

#include "bits/stdc++.h"
using namespace std;

const int N = 100010; // 数组大小，根据需求调整

struct Node {
    int value;    // 节点值
    int lson;     // 左子节点索引，0表示空
    int rson;     // 右子节点索引，0表示空
} tree[N];

int idx = 1; // 当前可用的节点索引，从1开始（0表示空节点）
unordered_map<int, int> val_to_idx; // 值到索引的映射
int n;


// 创建新节点（如果已存在则返回现有索引）
int create(int value) {
    if (val_to_idx.count(value)) {
        return val_to_idx[value];
    }
    tree[idx] = {value, 0, 0};
    val_to_idx[value] = idx;
    return idx++;
}

// 构建二叉树
void build(int n) {
    for (int i = 0; i < n; i++) {
        int root_val, l_val, r_val;
        cin >> root_val >> l_val >> r_val;

        int root_idx = create(root_val);

        if (l_val != 0) {
            int l_idx = create(l_val);
            tree[root_idx].lson = l_idx;
        }

        if (r_val != 0) {
            int r_idx = create(r_val);
            tree[root_idx].rson = r_idx;
        }
    }
}

void preorder(Node root) {
    cout << root.value << ' ';

    if (root.lson)
        preorder(tree[root.lson]);
    if (root.rson)
        preorder(tree[root.rson]);
}

void inorder(Node root) {
    if (root.lson)
        inorder(tree[root.lson]);

    cout << root.value << ' ';

    if (root.rson)
        inorder(tree[root.rson]);
}

void postorder(Node root) {
    if (root.lson)
        postorder(tree[root.lson]);
    if (root.rson)
        postorder(tree[root.rson]);

    cout << root.value << ' ';
}

void bfs(Node root) {
    queue<Node> Q;
    Q.push(root);

    while (!Q.empty()) {
        Node node = Q.front();
        Q.pop();
        cout << node.value << ' ';

        if (node.lson)
            Q.push(tree[node.lson]);
        if (node.rson)
            Q.push(tree[node.rson]);
    }
}

// 查找根节点（没有父节点的节点）
int find_root() {
    // 标记所有出现的节点
    vector<bool> has_parent(idx + 1, false);

    for (int i = 1; i < idx; i++) { // 对于节点i，它的子节点一定有父节点
        if (tree[i].lson != 0) {
            has_parent[tree[i].lson] = true;
        }
        if (tree[i].rson != 0) {
            has_parent[tree[i].rson] = true;
        }
    }

    // 找到没有父节点的节点（根节点）
    for (int i = 1; i < idx; i++) {
        if (!has_parent[i]) {
            return i;
        }
    }
    return 1; // 默认返回第一个节点
}

int main() {
    cin >> n;

    build(n);

    int root = find_root();

    cout << "先序遍历:" << endl;
    preorder(tree[root]);
    cout << '\n';
    cout << "中序遍历:" << endl;
    inorder(tree[root]);
    cout << '\n';
    cout << "后序遍历:" << endl;
    postorder(tree[root]);
    cout << '\n';
    cout << "层序遍历:" << endl;
    bfs(tree[root]);

    return 0;
}

输入格式：

第1行一个数n代表节点个数

第2至n+1行三个数root, l, r，代表根节点、左右子节点的值

输入：
9
1 2 3
2 4 5
3 6 0
4 7 8
5 0 9
6 0 0
7 0 0
8 0 0
9 0 0
输出：
先序遍历:
1 2 4 7 8 5 9 3 6
中序遍历:
7 4 8 2 5 9 1 6 3
后序遍历:
7 8 4 9 5 2 6 3 1
层序遍历:
1 2 3 4 5 6 7 8 9

改进建议：

这里传递的参数都是Node类型的，导致调用一次就复制一遍Node，效率不如int高。请尝试修改代码，传递索引为参数。

如何根据先序遍历、中序遍历求后序遍历，或根据后序遍历、中序遍历求先序遍历？

核心思想：

所有方法都基于二叉树遍历的一个核心性质：

先序遍历 (Preorder)：[根节点] + [左子树的先序遍历] + [右子树的先序遍历]
中序遍历 (Inorder)：[左子树的中序遍历] + [根节点] + [右子树的中序遍历]
后序遍历 (Postorder)：[左子树的后序遍历] + [右子树的后序遍历] + [根节点]

解决问题的关键是：利用“根节点”在中序遍历中的位置，将序列划分为左子树和右子树，然后递归地处理这些子树。

由此也可以看出：想要根据两种方式的遍历结果求树/另一种遍历，必须要有中序遍历，因为只有中序遍历才能把左右子树划分开来。

问题一：根据先序遍历和中序遍历求后序遍历

步骤（递归方法）：

确定根节点：先序遍历的第一个元素必定是整个二叉树的根节点。
定位根节点在中序中的位置：在中序遍历序列中找到这个根节点。该位置将中序遍历序列清晰地分割为三部分：
- 根节点左边的所有元素：左子树的中序遍历
- 根节点
- 根节点右边的所有元素：右子树的中序遍历
计算左右子树的大小：根据上一步分割的结果，可以确定左子树和右子树分别包含的节点个数。
递归构建左右子树：
- 左子树的先序遍历：从原始先序序列中，跳过第一个根节点，取紧接着的 左子树节点个数 个元素。
- 右子树的先序遍历：先序序列中剩下的部分。
递归处理：对左子树和右子树分别递归地重复步骤 1-4。
组合结果（后序）：将递归得到的左子树的后序序列、右子树的后序序列和根节点按顺序组合，即 左子树后序 + 右子树后序 + 根。

问题二：根据后序遍历和中序遍历求先序遍历

步骤（递归方法）：

这个方法与前一个非常对称。

确定根节点：后序遍历的最后一个元素必定是整个二叉树的根节点。
定位根节点在中序中的位置：在中序遍历序列中找到这个根节点。该位置将中序遍历序列分割为：
- 左子树的中序遍历
- 根节点
- 右子树的中序遍历
计算左右子树的大小：根据分割结果确定左右子树的节点个数。
递归构建左右子树：
- 左子树的后序遍历：从原始后序序列中，从开头取 左子树节点个数 个元素。
- 右子树的后序遍历：后序序列中紧接着的 右子树节点个数 个元素（最后一个根节点之前的那些元素）。
递归处理：对左子树和右子树分别递归地重复步骤 1-4。
组合结果（先序）：将根节点、递归得到的左子树的先序序列和右子树的先序序列按顺序组合，即 根 + 左子树先序 + 右子树先序。

C++代码：

#include <bits/stdc++.h>
using namespace std;

vector<int> preInToPost(vector<int>& pre, vector<int>& in,
    int preStart, int preEnd,
    int inStart, int inEnd,
    unordered_map<int, int>& inMap)
{
    if (preStart > preEnd) return {};

    int rootVal = pre[preStart];
    int rootIndex = inMap[rootVal];
    int leftSize = rootIndex - inStart;


    vector<int> leftPost = preInToPost(pre, in,
        preStart + 1, preStart + leftSize,
        inStart, rootIndex - 1, inMap);

    vector<int> rightPost = preInToPost(pre, in,
        preStart + leftSize + 1, preEnd,
        rootIndex + 1, inEnd, inMap);

    // 组合结果：左子树后序 + 右子树后序 + 根
    vector<int> result;
    result.insert(result.end(), leftPost.begin(), leftPost.end());
    result.insert(result.end(), rightPost.begin(), rightPost.end());
    result.push_back(rootVal);

    return result;
}

vector<int> postInToPre(vector<int>& post, vector<int>& in,
    int postStart, int postEnd,
    int inStart, int inEnd,
    unordered_map<int, int>& inMap)
{
    if (postStart > postEnd) return {};

    int rootVal = post[postEnd];
    int rootIndex = inMap[rootVal];
    int leftSize = rootIndex - inStart;

    vector<int> leftPre = postInToPre(post, in,
        postStart, postStart + leftSize - 1,
        inStart, rootIndex - 1, inMap);

    vector<int> rightPre = postInToPre(post, in,
        postStart + leftSize, postEnd - 1,
        rootIndex + 1, inEnd, inMap);

    // 组合结果：根 + 左子树先序 + 右子树先序
    vector<int> result;
    result.push_back(rootVal);
    result.insert(result.end(), leftPre.begin(), leftPre.end());
    result.insert(result.end(), rightPre.begin(), rightPre.end());

    return result;
}

int main() {
    int n;

    // 读取树1的先序和中序遍历
    cin >> n;
    vector<int> pre1(n), in1(n);
    for (int i = 0; i < n; i++) cin >> pre1[i];
    for (int i = 0; i < n; i++) cin >> in1[i];

    // 读取树2的后序和中序遍历
    cin >> n;
    vector<int> post2(n), in2(n);
    for (int i = 0; i < n; i++) cin >> post2[i];
    for (int i = 0; i < n; i++) cin >> in2[i];

    // 创建中序遍历值的索引映射（加速查找）
    unordered_map<int, int> inMap1, inMap2;
    for (int i = 0; i < (int)in1.size(); i++) inMap1[in1[i]] = i;
    for (int i = 0; i < (int)in2.size(); i++) inMap2[in2[i]] = i;

    // 计算树1的后序遍历
    vector<int> post1 = preInToPost(pre1, in1, 0, pre1.size()-1, 0, in1.size()-1, inMap1);

    // 计算树2的先序遍历
    vector<int> pre2 = postInToPre(post2, in2, 0, post2.size()-1, 0, in2.size()-1, inMap2);

    // 输出结果
    for (int i = 0; i < (int)post1.size(); i++) {
        if (i > 0) cout << " ";
        cout << post1[i];
    }
    cout << endl;

    for (int i = 0; i < (int)pre2.size(); i++) {
        if (i > 0) cout << " ";
        cout << pre2[i];
    }
    cout << endl;

    return 0;
}

输入格式：

第一行：树1的节点数n

接下来n行：树1的先序遍历

接下来n行：树1的中序遍历

下一行：树2的节点数n

接下来n行：树2的后序遍历

接下来n行：树2的中序遍历

输出格式：

第一行：树1的后序遍历（空格分隔）

第二行：树2的先序遍历（空格分隔）

示例输入：
7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
7
4 5 2 6 7 3 1
4 2 5 1 6 3 7
示例输出：
4 5 2 6 7 3 1
1 2 4 5 3 6 7

入门：计算机的基本构成

Sun, 24 Aug 2025 16:37:00 GMT

计算机的构成

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

计算机由软件和硬件构成。

-　硬件是指看得见摸得着的各种电子元器件。如主机、键盘、鼠标等。-　软件看不见摸不着，但在逻辑上，我们确实可以感知到它的存在，它由人们事先编制的具有某种功能的程序组成。比如操作系统、编程语言等。

计算机的软件通常又分为：系统软件和应用软件。

系统软件：又称为系统程序，主要用来管理整个计算机系统，监视服务，使系统资源得到合理调度。它包括：操作系统、语言处理程序、数据库管理系统、网络软件、服务程序等。
应用软件：又称为应用程序，它是用户根据需要事先编制的程序。比如 QQ、微信等。

硬件系统

在冯 · 诺依曼体系中，计算机硬件系统是由运算器、控制器、存储器、输入设备和输出设备五大部件组成的。

随着计算机技术的发展，计算机硬件系统的组织结构发生了许多重大的变化，如运算器和控制器已组合成一个整体，称为中央处理器（Central Processing Unit，CPU）。

存储器已成为多级存储器体系，包含主存、高速缓存和外存三个层次。

软件系统

软件类别：系统软件和应用软件。

系统软件：又称为系统程序，主要用来管理整个计算机系统，监视服务，使系统资源得到合理调度。它包括：操作系统、语言处理程序、数据库管理系统、网络软件、服务程序等。
应用软件：又称为应用程序，它是用户根据需要事先编制的程序。比如 QQ、微信等。

你们玩过“开源游戏”吗？开源即时策略游戏——战地2100游玩体验

Sun, 17 Aug 2025 15:28:00 GMT

战地2100游玩体验

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

最近看小说，突然对即时战略游戏产生了强烈的冲动。但是在Linux上，想找点好玩的却不容易，因为例如红警等都是闭源软件，一般很少有对Linux的支持；而且一般都依托于Steam或者GOG Game进行售卖。尽管wine或者Proton等软件让Linux游玩Windows游戏没那么困难，但是闭源在Linux社区绝对不算是良好的选择。所以我盯上了Warzone 2100（战地2100）。

游戏介绍

据官网描述，这个游戏是1999年发行的，后来在2000年1月官方结束了支持。而在2004年，粉丝们请愿工作室能开放源代码，从此Warzone就走上了开源软件的道路。

历史悠久由南瓜工作室开发于90年代。 2004年独立。

2100 Warzone 最初由南瓜工作室开发，由Eidos Interactivity发行。 1999年，在微软的Windows和索尼的PlayStation上投放了该产品。南瓜工作室于2000年1月5日结束了对 Warzone 2100 的支持。

2004年，在粉丝们请愿后，根据开放源码许可证公开发布了 Warzone 的源码。自那时以来，在“Warzone 2100”项目的旗帜下，该项目一直得到社区的开发、维护和改进。

这款游戏是一款即时战略游戏,支持Windows、MacOS与Linux，可以说是全平台支持了；据官网上是这样介绍的：

为什么 Warzone 2100 震撼

设计战略。无限可重新玩。

单人战役

在人类几乎被核弹摧毁之后，指挥武装力量重建世界。

局域网 / 因特网多玩家

在本地网络上与您的朋友们玩游戏，或者在一个在线多人游戏大厅中试试手吧。

AI 机器人

与AI 机器人进行本地小规模战斗(或在多人游戏中添加为队友/敌人)，在无限重玩中练习你的技能。

广阔的科技树

超过400种不同的科技成就和丰富的科技树路径选择。

单位设计

使用灵活的设计系统定制你的单位，提供各种可能的单位和战术。

跨平台

支持 Windows，macOS，Linux，FreeBSD 等等，都有跨平台多人游戏支持！

游戏安装

Linux上可以直接使用

sudo apt install warzone2100

来安装，或者从官方GitHub页面/官网下载.tar.xz包自行编译安装，在GitHub上都有介绍。

Windows可以去微软应用商店安装，几十分钟就好了。

Warzone 2100 100%免费且开源的3D即时策略游戏。

[!NOTE] 在Linux/MacOS版本上，有一个名为sequences.wz的视频资源包不会自动下载，没有它一些游戏动画、教程、战役等都会加载异常，官网上有下载链接，速度不慢（至少没有某度网盘一样50kb/s）但要下载好也很费功夫。我这里下好了低质版本(其他版本死活下载失败)，我会放在网盘里开放下载，下载后放到配置目录即可（配置目录位置官网上有）。

使用体验

整体来说，除了UI界面有点古老，其他还是很不错的；丰富开放的玩法，局域网联机，精心打磨的背景图片以及昨晚在GitHub上看到的最近提交：10分钟前给足了我信心——这就是开源产品的魅力。

网盘资源地址

尝试解决Edge和Firefox滚动条样式不统一

Sat, 16 Aug 2025 14:46:00 GMT

尝试解决Edge和Firefox滚动条样式不统一

作者为蒟蒻高中牲，若有不妥之处请多多包含，并望于评论区指正，不胜感激！

之前在MDN学习CSS时，看到了一些关于滚动条样式的属性scrollbar-width，想着去观察一下我的网站的滚动条。发现是最初很细，鼠标悬停时变粗，既好看又方便。直到我一不小心在Edge上打开了我的网站，一看这个滚动条：太不好看了！于是便琢磨把Edge上的调整一下。网上查到Chromium浏览器都不支持scrollbar-width，但是查到可以使用非标准的伪元素::-webkit-scrollbar来自定义滚动条，于是便尝试通过这种方式模拟类似的效果。

目的：

默认情况下，将滚动条设置为较细。
当鼠标悬停在滚动条上时，将滚动条变粗。

首先设置一下滚动条的大小。

::-webkit-scrollbar {
  width: 8px; /* 默认细宽度 */
  height: 8px; /* 水平滚动条高度 */
}

接下来设置滑动条块的样式，background用灰色填充，border-radius设置圆角，用border创建一个一定大小的透明边框实现变细效果。在鼠标悬停时移除就实现了“变粗”。

::-webkit-scrollbar-thumb {
  background: #c1c1c1;
  border-radius: 4px;
  border: 2px solid transparent; /* 创建透明边框 */
  background-clip: padding-box; /* 确保背景不渗透到边框 */
}

::-webkit-scrollbar-thumb:hover {
  background: #a8a8a8;
  border: 0; /* 悬停时移除透明边框实现"变粗"效果 */
}

Luogu P1217 回文质数

Fri, 15 Aug 2025 11:09:00 GMT

题目传送门

这是一道我弟拿给我做题目，本来想着普及−应该挺简单的，结果翻车了

题目解读

本题要求我们找出给定区间内的所有“回文质数”^1。我一看就想着：先筛质数，再判断是不是回文数~~，结果大意失荆州——开了一个占用4G内存的prime[100000000]~~于是我终于注意到了题目中的提示：

说明/提示

Hint 1: Generate the palindromes and see if they are prime.

提示 1: 找出所有的回文数再判断它们是不是质数（素数）.

Hint 2: Generate palindromes by combining digits properly. You might need more than one of the loops like below.

提示 2: 要产生正确的回文数，你可能需要几个像下面这样的循环。

题目翻译来自NOCOW。

USACO Training Section 1.5

产生长度为 5 的回文数：
for (d1 = 1; d1 <= 9; d1+=2) { // 只有奇数才会是素数
 for (d2 = 0; d2 <= 9; d2++) {
 for (d3 = 0; d3 <= 9; d3++) {
 palindrome = 10000*d1 + 1000*d2 +100*d3 + 10*d2 + d1;//(处理回文数...)
 }
 }
}

于是我便把提示里的代码复制了几份～

AC 代码

#include <bits/stdc++.h>
using namespace std;

// 判断一个数是否为质数
bool isPrime(int n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;

    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0) return false;
    }
    return true;
}

vector<int> palindromes;

int main() {
    int st, ed;
    scanf("%d%d", &st, &ed);

    // 生成所有可能的回文数

    // 1位回文数
    for (int i = 1; i <= 9; i++) {
        palindromes.push_back(i);
    }
    // 偶数位回文数(除了11)都能被11整除，不是回文数
    // 2位回文数
    palindromes.push_back(11);

    // 3位回文数
    for (int i = 1; i <= 9; i += 2) { // 只考虑奇数开头，偶数开头的必不是质数
        for (int j = 0; j <= 9; j++) {
            palindromes.push_back(i * 101 + j * 10); // iji形式
        }
    }

    // 5位回文数
    for (int i = 1; i <= 9; i += 2) {
        for (int j = 0; j <= 9; j++) {
            for (int k = 0; k <= 9; k++) {
                palindromes.push_back(i * 10001 + j * 1010 + k * 100); // ijkji形式
            }
        }
    }

    // 7位回文数
    for (int i = 1; i <= 9; i += 2) {
        for (int j = 0; j <= 9; j++) {
            for (int k = 0; k <= 9; k++) {
                for (int l = 0; l <= 9; l++) {
                    palindromes.push_back(i * 1000001 + j * 100010 + k * 10100 + l * 1000); // ijklkji形式
                }
            }
        }
    }

    // 9位回文数（虽然超出了1亿，但为了完整性）
    for (int i = 1; i <= 9; i += 2) {
        for (int j = 0; j <= 9; j++) {
            for (int k = 0; k <= 9; k++) {
                for (int l = 0; l <= 9; l++) {
                    for (int m = 0; m <= 9; m++) {
                        int palindrome = i * 100000001 + j * 10000010 + k * 1000100 + l * 100010 + m * 10000;
                        if (palindrome <= 100000000) { // 只添加不超过1亿的
                            palindromes.push_back(palindrome);
                        }
                    }
                }
            }
        }
    }

    // 排序
    sort(palindromes.begin(), palindromes.end());

    // 遍历回文数数组，找出其中的质数并输出
    for (int palindrome : palindromes) {
        if (palindrome > ed) break;
        if (palindrome >= st && isPrime(palindrome)) {
            printf("%d\n", palindrome);
        }
    }

    return 0;
}

Over!

Luogu P3218 题解

Sat, 09 Sep 2023 00:00:00 GMT

Luogu P3218

题目大意：

求取被指定的多条路径覆盖的树中找出被覆盖次数最多的节点

!!INPUT：

第一行
- N: 节点
- K: 路径数
接下来N - 1行，每一行：
- x y: 节点x与y之间有通路
接下来K行：
- s t: 路径端点

思路

考虑使用链式前向星建树。

遍历路上的节点，经过一次加1。

题中路径已知两端点，记起点为 $u$ , 终点为 $ v $ 则路径为

$$ u \to lca(u, v) \to v $$

若直接遍历，则时间复杂度为$ O(NK)$ ，按题目数据最多遍历$ 5 \times 10^{10}$ , 这是不能接受的。

考虑使用树上差分优化。

关于前缀和 & 差分的知识，可以去OI-WiKi中学习。

如果要对结点 $x$ 和 $y$ 之间的路径上的所有点权都加 $v$，可以对它的差分序列 ${D_x}$ 做如下操作：

$$ \begin{aligned} D_x &\gets D_x + v, \ D_{\operatorname{lca}(x, y)} &\gets D_{\operatorname{lca}(x, y)} - v,\ D_y &\gets D_y + v, \ D_{\operatorname{fa}(\operatorname{lca}(x, y))} &\gets D_{\operatorname{fa}(\operatorname{lca}(x, y))} - v. \end{aligned} $$

在所有修改操作完成后，可以计算一次子树和，就能得到更新后的点权。

倍增求LCA

首先第一遍DFS预处理数组，得到二维倍增数组 $fa$ 及深度数组 depth。fa[u][i]表示节点i往上走$2^i$步的父节点。

接下来进行LCA查询，具体步骤：跳、跳、跳……然后就到LCA了。

从最低节点出发，往上跳diff步即可。具体操作：

for (int i = 0; i <= LOG; i++)
    if (diff & (1 << i)) // 若 diff 的二进制第 i 位为 1
        u = fa[u][i];

再两个点从同一高度出发，~~一起蹦蹦跳跳~~直到两点相同。虽然使用while循环可以优化一丢丢，但是这里还是给出for循环的代码：

for (int i = 0; i <= LOG; i++)
    if (fa[u][i] != fa[v][i])
    {
        u = fa[a][i];
        v = fa[b][i];
    }

$lca(u, v)$即为此时的$u = v $的父节点即$fa_{u,0}$。

树上差分

树上差分和一维差分略有不同。树上差分是子节点**"在后续的累加过程中，要向它的父节点（以及自己）传递多少值"**。

例如对于树：

graph TD
1/0 --> 2/0
1/0 --> 3/0
2/0 --> 4/0
2/0 --> 5/0
3/0 --> 6/0
3/0 --> 7/0

要给路径$2 \to 1 \to 7$加上 $1$ , 只需要给

$$ D_7 \leftarrow D_7 + 1 \ D_2 \leftarrow D_2 + 1\ D_1 \leftarrow D_1 - 1\ $$

如果 $$lca(u,v)$$ 不是根节点，则 $father(lca(u, v))$ 也需要自减。

因为在$D_u$和$D_v$自增的过程中，$lca(u,v)$及其以上的所有节点的值都相应地减了两个$1$，因此给$D_{lca(u,v)}$及其父节点各自减一刚好可以抵消。

在最后结束时，使用前缀和合并差分数组即可得出初始值。

注意：需要使用后序遍历（即左->右->根的顺序），因为根节点需要统计所有子节点的贡献（直接在递归子节点后加上子节点的值即可）。

**提示：**在后序遍历之前记得先初始化节点值为差分值（因为也包括它自己的贡献）

示例代码

#include <bits/stdc++.h>
using namespace std;

const int LOG = 20;
const int MAXN = 5e4 + 10;

int fa[MAXN][LOG << 2], depth[MAXN], D[MAXN], val[MAXN];
vector<int> tree[MAXN];

void dfs(int x, int father)
{
    fa[x][0] = father;
    for (int i = 1; i <= LOG; i++)
    {
        fa[x][i] = fa[fa[x][i-1]][i-1]; // 一分为二
    }
    for (auto child: tree[x])
    {
        if (child == fa[x][0]) continue;
        depth[child] = depth[x] + 1; // 深度+1
        dfs(child, x);
    }
}

int lca(int u, int v)
{
    if (depth[v] > depth[u]) swap(u, v);
    int diff = depth[u] - depth[v];
    for (int i = 0; i <= LOG; i++)
        if (diff & (1 << i)) // 若 diff 的第 i 位为 1
            u = fa[u][i];
    if (u == v) return u;
    if (fa[u][0] == fa[v][0]) return fa[u][0];
    for (int i = LOG; i >= 0; i--)
        if (fa[u][i] != fa[v][i])
        {
            u = fa[u][i];
            v = fa[v][i];
        }
    return fa[u][0];
}

void accumulate(int x, int father)
{
    val[x] = D[x];
    for (auto child: tree[x])
    {
        if (child == father) continue;
        accumulate(child, x);
        val[x] += val[child];
    }
}

signed main()
{
    int n, k;
    cin >> n >> k;
    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    dfs(1, 0); // 根节点的爸爸是 0

    for (int i = 1; i <= k; i++)
    {
        int s, t;
        cin >> s >> t;

        int l = lca(s, t);

        ++D[s];
        ++D[t];
        --D[l];

        if (fa[l][0])
            --D[fa[l][0]];
    }

    accumulate(1, 0);

    int ans = -0x3f3f3f3f;
    for (int i = 1; i <= n; i++)
    {
        ans = max(ans, val[i]);
    }

    cout << ans << '\n';

    return 0;
}

小石崽的小窝

网站更新啦

关于本网站更新的说明

Linux 基础 & Python 控制流

Linux 基础使用 & Python 控制流

Linux 基础使用

1. 开发环境配置指南

1.1 编辑器安装与配置

1.3 基础命令扩展学习

Python 控制流

分支结构

循环结构

while 循环

for 循环

Python 学习任务：输出 1 到 n 中的所有质数

任务分析

实现步骤

示例代码

代码解释

优化建议

扩展练习

AI 生成的详解

Python 控制流详解

一、分支结构深入

1.1 条件表达式

1.2 if 语句的完整结构

1.3 嵌套 if 语句

1.4 逻辑运算符

二、循环结构深入

2.1 while 循环详解

2.2 for 循环详解

2.3 循环的 else 子句

2.4 嵌套循环

三、质数判断程序的优化与扩展

3.1 优化版本 - 使用函数封装

3.2 高级版本 - 埃拉托斯特尼筛法

3.3 扩展练习 - 质数分解

四、综合练习

4.1 猜数字游戏

4.2 计算器程序

五、学习建议

5.1 调试技巧

5.2 编程习惯

5.3 进阶学习

六、实践任务

任务1：斐波那契数列

任务2：闰年判断

任务3：最大公约数和最小公倍数

任务4：回文数判断

Python入门 #1

第一个程序

交互式解释器介绍

实践

在文件中写代码

实践

# P6824 🉑乐题解

🉑乐题解

题目分析

解题思路

暴力做法

优化思路

查询

Open Source: The Hacker's Utopia

Open Source: The Hacker's Utopia

Linux终端使用帮助

终端使用帮助

常用命令一览

sudo - 提升权限

chmod：权限管理之一

mkdir touch

echo

ls

cat

pwd

cd

rm 删除文件/目录

辅助字符（部分常用的）

&&

> / >>

|管道字符。

`chmod`：权限管理之一

`&&`

`>` / `>>`

`|`管道字符。