淼畔

解决 MCSM 面板不能直接使用 run 启动 run.bat 作为启动命令的问题

Sun, 05 Apr 2026 19:25:00 GMT

在 Windows Server 中使用 MCSM 面板时，某次版本更新后遇到不能直接使用 run 启动 run.bat 作为启动命令的问题。

↑错误截图示例

仔细分析后发现，是由于7491d7e7提交（或者说v10.11.0）开始，实例默认不开启仿真终端导致的。只要在终端设置里开启仿真终端即可正常启动。

禁用 Firefox 全屏提示和动画

Tue, 03 Mar 2026 22:50:00 GMT

about:config 里面，
full-screen-api.warning.timeout 设为 $0$，
full-screen-api.transition-duration.enter 和 full-screen-api.transition-duration.leave 设为 0 0。

把 GitHub 网站上显示的提交消息全部替换成“修复了一些已知问题”

Tue, 10 Feb 2026 17:00:00 GMT

安装方法

安装浏览器插件 Tampermonkey。
打开 Greasy Fork 发布页
点击安装按钮，确认安装。
刷新 GitHub 页面，享受清爽的阅读体验。

效果演示

安装前

安装后

仓库地址

GitHub 仓库

免责声明

本脚本仅供娱乐，请勿在需要认真审查代码变更的生产环境中使用（笑）。

当你发现 TRAE 对 Java 环境变量改变无动于衷

Tue, 03 Feb 2026 20:40:00 GMT

如果你们使用TRAE的时候发现改了Java的环境变量结果死都不能应用到终端，可能是这个干的：

直接禁用就好了。不要问我怎么知道的。

闲得没事还是别折腾 Astro 了

Sat, 31 Jan 2026 21:20:00 GMT

就挺折腾的。（

AI Studio GPU 占用过高导致卡顿的解决办法

Sun, 07 Dec 2025 18:20:00 GMT

loading-indicator {
    display: none !important;
}

.turn-footer.ng-star-inserted {
    display: none;
}

Firefox 禁用按下 Alt 显示菜单

Wed, 03 Dec 2025 20:15:00 GMT

进入 about:config，将 ui.key.menuAccessKey 默认的 18 改成 0，重启浏览器。

题解：Kuangyeye's Random Number

Wed, 03 Dec 2025 13:30:00 GMT

这是一道 Hunan University Judge Online 的题目。题目链接：Kuangyeye's Random Number

Problem Description

Kuangyeye has a random number in range [0,1023],now he wants to you guess it.

Input

No input

Output

output contains one integer,representing Kuangyeye’s random number

Sample Input

no input

Sample Output

100

Note

Sample output may not be the answer.

Solution

print(276)

Windows 的一些设置

Tue, 02 Dec 2025 15:31:00 GMT

使用 S3 睡眠模式

reg add HKLM\System\CurrentControlSet\Control\Power /v PlatformAoAcOverride /t REG_DWORD /d 0

开机默认启用 NumLock

注册表 HKEY_USERS\.DEFAULT\Control Panel\Keyboard 键 InitialKeyboardIndicators 值改为 2。

开启和关闭临时 IPv6 地址

关闭

netsh interface ipv6 set privacy state=disabled

开启

netsh interface ipv6 set privacy state=enabled

禁止鼠标唤醒

到设备管理器里，除了鼠标要禁用唤醒，还要把一个叫键盘的也禁用唤醒。

薄荷输入法配置

Tue, 02 Dec 2025 11:32:00 GMT

右键输入法，选择“用户文件夹”。

启用微软双拼

打开 default.yaml，把微软双拼取消注释，其他不用的可以注释掉，提高部署速度。右键输入法，部署。可通过 Ctrl + ` 切换方案。

更改候选词个数、最大输入长度

创建 double_pinyin_mspy.custom.yaml，填入以下内容：

patch:
  "menu/page_size": 7
  codeLengthLimit_processor: 100

候选词水平排列

打开 weasel.custom.yaml，填入以下内容：

patch:
  # stacked | linear | tabled 候选项排列方向(如果希望水平，设置linear)
  style/candidate_list_layout: linear
  style/horizontal: true

安装万象拼音模型

在这里下载模型，格式为.gram，移动到用户文件夹，创建 double_pinyin_mspy.custom.yaml，填入以下内容：

patch:
  # 语言模型
  "grammar/language": wanxiang-lts-zh-hans
  "grammar/collocation_max_length": 5
  "grammar/collocation_min_length": 2

  # translator 内加载
  "translator/contextual_suggestions": true
  "translator/max_homophones": 7
  "translator/max_homographs": 7

关闭一些快捷键

打开 default.yaml，在 key_binder 和 ascii_composer 那里自己注释掉一些。

关闭双拼编码转义

打开或创建 double_pinyin_mspy.custom.yaml，添加：

patch:
  "translator/preedit_format": []

输入首字母被吞等奇怪问题

打开 weasel.custom.yaml，填入以下内容：

patch:
  style/inline_preedit: true

导入词库

不会！（即答）

小白被 Linux 玩随便记录点东西

Fri, 28 Nov 2025 16:30:00 GMT

声明：本文有大量内容由 AI 生成，但是这些内容均经过验证（特殊标注除外）。

关闭动画

第一步：关闭 KDE 桌面本身的动画（窗口、菜单等）

这一步会让你的开始菜单、窗口最大化/最小化变得瞬间完成。

打开 系统设置 (System Settings)。
进入 工作区行为 (Workspace Behavior) -> 常规行为 (General Behavior)。
找到 动画速度 (Animation speed) 选项。
将滑块一直拉到最右侧的 “即时 (Instant)”。
点击应用。

效果： 此时，KDE 的所有原生窗口、菜单弹出将不再有过渡动画。但这一步通常不会影响 QQ 或 Chrome 内部的网页滚动效果。

第二步：强制第三方应用（QQ、浏览器等）关闭动画

大多数现代 Linux 应用（包括 Linux 版 QQ、Chrome、Firefox）都是基于 GTK 或 Electron 开发的。它们并不直接读取 KDE 的动画设置，而是读取一个标准的 GTK 配置文件。我们需要手动创建这个配置来告诉它们“请勿播放动画”。

打开你的终端（Konsole）。

复制并运行以下命令（这是一条命令，直接复制粘贴回车即可）：

mkdir -p ~/.config/gtk-3.0 ~/.config/gtk-4.0 && \
echo -e "[Settings]\ngtk-enable-animations=0\ngtk-primary-button-warps-slider=0" | tee ~/.config/gtk-3.0/settings.ini ~/.config/gtk-4.0/settings.ini

如果命令执行后没有报错，就是成功了。

原理说明：

gtk-enable-animations=0：这是核心。它告诉所有读取 GTK 配置的应用（包括 QQ、Chrome、Firefox）全局禁用动画。这通常会自动触发网页和应用内的“减少运动 (prefers-reduced-motion)”模式，从而关闭平滑滚动。

gtk-primary-button-warps-slider=0（可选）：这会让滚动条点击行为变回“点击哪里跳到哪里”，而不是一页页翻，符合关闭动画后的干脆手感。

第三步：验证与后续

做完上述两步后，建议注销并重新登录（或者重启电脑）以确保所有后台进程（如 QQ 的后台服务）重新读取配置。

重启后：

QQ / 微信 / 钉钉：聊天列表滚动应该会变得生硬（瞬间跳转），不再平滑滚动。
浏览器 (Chrome/Firefox)：你可以访问 prefers-reduced-motion 测试页面来测试。如果显示 "Reduced motion preference is detected"，说明你的浏览器已经成功识别到了系统的“无动画”指令。

补充：如果某些应用依然有平滑滚动

如果极少数应用（例如纯 Qt 应用或特定版本的浏览器）依然有平滑滚动，你可以手动进行微调：

Firefox：在地址栏输入 about:config，搜索 general.smoothScroll 并双击设置为 false。
Chrome/Edge：在地址栏输入 chrome://flags，搜索 Smooth Scrolling 并设置为 Disabled。

大多数情况下，执行前两步就已经能达到你想要的效果了。

禁用 USB 鼠标唤醒

找到鼠标的 ID

我们需要知道你鼠标独一无二的“身份证号”（Vendor ID 和 Product ID）。

打开终端，输入：
```
lsusb
```
在输出列表中找到你的鼠标。它通常包含 "Mouse"、"Optical" 或品牌名（如 Logitech, Razer 等）。你会看到类似这样的一行：

Bus 001 Device 003: ID 046d:c077 Logitech, Inc. M105 Optical Mouse

记下 ID 后面那两组字符。在这个例子中，Vendor ID 是 046d，Product ID 是 c077。请记下你自己鼠标的这两个号码。

创建 Udev 规则

我们需要告诉 Linux 系统：“每当插入这个 ID 的设备时，自动把它的唤醒功能关掉。”

创建规则文件：

sudo nano /etc/udev/rules.d/50-disable-mouse-wake.rules

粘贴以下内容（注意修改为你自己的 ID）：
```
# 禁止特定鼠标唤醒电脑
ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ATTRS{idVendor}=="你的厂商ID", ATTRS{idProduct}=="你的产品ID", ATTR{power/wakeup}="disabled"
```
举例：如果你的 ID 是 046d:c077，那么那一行应该是： ACTION=="add", SUBSYSTEM=="usb", DRIVERS=="usb", ATTRS{idVendor}=="046d", ATTRS{idProduct}=="c077", ATTR{power/wakeup}="disabled"
保存并退出（Ctrl+O, Enter, Ctrl+X）。

生效与测试

重载规则：
```
sudo udevadm control --reload
```
拔掉鼠标，重新插上（这一步必须做，为了触发规则）。

特殊情况说明

如果你的键盘和鼠标共用一个接收器，那可能分不开。

Shebang

Shebang (#!) 是写在脚本文件第一行的一个特殊指令，用来告诉操作系统**“请用这个程序来运行我”**。

详细解释

1. 它长什么样？

Shebang 由井号（#）和感叹号（!）组成，后面紧跟着一个程序（解释器）的绝对路径。

Bash 脚本: #!/bin/bash
Python 脚本: #!/usr/bin/python3
Node.js 脚本: #!/usr/bin/env node

2. 它是如何工作的？

当你尝试像运行一个普通程序那样执行一个脚本文件时（例如，在终端里输入 ./myscript.sh），操作系统会做以下事情：

它会检查文件的最开头。
如果它看到了 #! 这个标记，它就不会把这个文件当成普通的二进制程序来运行。
相反，它会读取 #! 后面的路径（比如 /bin/bash），然后启动这个程序。
最后，它会把你的脚本文件路径作为参数传递给那个程序去执行。

所以，运行一个第一行写着 #!/bin/bash 的脚本，就等同于在命令行手动输入 bash ./myscript.sh。

3. 为什么它很重要？

指定正确的“语言”：脚本可以用很多种语言来写（Bash, Python, Perl 等）。Shebang 可以确保无论用户当前的环境是什么，你的脚本都会被正确的解释器执行，避免因语法不兼容而出错。
让脚本能直接运行：有了 Shebang，你只需要给文件加上执行权限 (chmod +x script.sh)，就可以像运行一个内置命令一样直接通过 ./script.sh 来执行它，非常方便。
提高可移植性：尤其当使用 #!/usr/bin/env python3 这种形式时，它会自动在系统的环境变量 PATH 中寻找 python3 解释器，而不是写死一个固定的路径（比如 /usr/bin/python3）。这使得脚本在不同系统（这些系统中 python3 可能安装在不同位置）之间有更好的兼容性。

总结

Shebang 就像是给脚本文件贴上了一个“使用说明”，这个说明非常简洁，就是告诉操作系统该找谁（哪个解释器）来读懂并执行这个文件的内容。它虽然看起来像一行注释，但对于操作系统来说，它是一条有特殊意义的指令。

ssh 卡死

修改 /etc/ssh/ssh_config 添加以下参数：

ServerAliveInterval 10  # 每隔 10 秒发送一个请求
ServerAliveCountMax 3  # 允许超时的次数

睡眠模式改为 `deep`

临时切换

sudo sh -c 'echo deep > /sys/power/mem_sleep'

永久切换

编辑 /etc/default/grub，找到 GRUB_CMDLINE_LINUX_DEFAULT 这一行，在引号内部，添加 mem_sleep_default=deep。

修改前可能长这样：

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

修改后应该长这样：

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash mem_sleep_default=deep"

然后执行

sudo update-grub

开机自动打开 NumLock

（可能仅适用于 Kubuntu）

打开 系统设置 (System Settings)。
在左侧菜单找到 输入设备 (Input Devices) -> 键盘 (Keyboard)。
在右侧点击 硬件 (Hardware) 选项卡。
找到 Plasma 启动时的 NumLock 状态 (NumLock on Plasma Startup)。
将其设置为 开启 (Turn On)。
点击右下角的 应用 (Apply)。

开机自动登录时提示 `Unlock Login Keyring`

具体来讲，提示：

Authentication required
The login keyring did not get unlocked when you logged into your computer.
Password:

解决方法

因为之前折腾过 lightdm，系统里现在混用了 GNOME 的密钥环服务（所以提示语是 Login Keyring）。需要把这个密钥环的密码改成空（Blank）。

请按以下步骤操作，只需做一次：

第一步：安装管理工具

Kubuntu 默认可能没有带 GNOME 的密钥管理工具，我们需要装一个叫 seahorse 的软件。打开终端（Konsole），输入并回车：

sudo apt update
sudo apt install seahorse

第二步：修改密钥环密码为空

按 Win 键打开应用程序菜单，搜索 "Passwords and Keys" 或者 "seahorse" 并打开它。
在左侧栏，你应该能看到 "Login"（或者叫“登录”）这一项。
右键点击 "Login"，选择 "Change Password"（更改密码）。
旧密码： 输入你现在的用户登录密码。
新密码： 什么都不要输，直接留空！ 然后点继续。
确认新密码： 再次留空，直接点继续。
系统会弹出一个警告说这样“不安全（Unsafe storage）”，点击 "Continue"（继续） 即可。

第三步：重启电脑

重启之后，系统会自动登录，并且因为密钥环没有密码，它会自动解锁，就不会再弹窗烦你了。

注意： 这样做唯一的副作用是：如果你电脑借给别人用，他们打开你的浏览器就能看到保存的网站密码（因为不再需要密码解锁了）。既然你选择了自动登录，说明你在这台电脑上更看重方便而非极致的安全，所以这是标准解决方案。

双系统隐藏 grub

编辑 /etc/default/grub，将 GRUB_DISABLE_OS_PROBER 取消注释并改成 true。然后执行

sudo update-grub

临时需要 grub时，开机长按 Shift 即可。

把登录界面改回 SDDM

sudo dpkg-reconfigure sddm

NVIDIA GPU 突破 55W 功耗墙

启用 nvidia-powerd.service。

关闭临时 IPv6 地址

编辑 /etc/sysctl.d/10-ipv6-privacy.conf，将文件中的 net.ipv6.conf.default.use_tempaddr = 2 改为 0，然后执行：

sudo sysctl --system

关闭独显

sudo prime-select intel

NVIDIA GPU 周期性卡顿

可能是轮询 nvidia-smi 干的。

利用 scp 传输文件

1、从服务器上下载文件

scp username@servername:/path/filename /var/www/local_dir（本地目录）

例如scp root@192.168.0.101:/var/www/test.txt 把192.168.0.101上的/var/www/test.txt 的文件下载到/var/www/local_dir（本地目录）

2、上传本地文件到服务器

scp /path/filename username@servername:/path

例如scp /var/www/test.php root@192.168.0.101:/var/www/ 把本机/var/www/目录下的test.php文件上传到192.168.0.101这台服务器上的/var/www/目录中

3、从服务器下载整个目录

scp -r username@servername:/var/www/remote_dir/（远程目录） /var/www/local_dir（本地目录）

例如:scp -r root@192.168.0.101:/var/www/test /var/www/

4、上传目录到服务器

scp -r local_dir username@servername:remote_dir

例如：scp -r test root@192.168.0.101:/var/www/ 把当前目录下的test目录上传到服务器的/var/www/ 目录

参考资料：https://www.cnblogs.com/jiangyao/archive/2011/01/26/1945570.html

微软大战代码怎么不能鼠标中键选择矩形区域

在 Linux 系统下的 VS Code 中，鼠标中键无法直接进行矩形选择（列选择），通常是因为 Linux 系统默认将“鼠标中键”定义为“粘贴选定内容”（Primary Selection Paste）。这导致当你尝试用中键拖拽时，VS Code 可能会优先识别为粘贴操作，或者与系统的剪贴板功能发生冲突。

以下是几种解决方法，按推荐程度排序：

方法一：修改 VS Code 设置（最推荐）

你可以禁用 VS Code 中“中键点击粘贴”的功能，从而恢复中键用于矩形选择的功能。

打开 VS Code 设置：按下 Ctrl + , 或者点击左下角齿轮图标 -> Settings。
在搜索框中输入：selectionClipboard。
找到 Editor: Selection Clipboard 选项。
取消勾选该选项。

效果： 禁用后，在 VS Code 内点击鼠标中键不再执行粘贴操作，此时按住鼠标中键并拖动，即可实现矩形区域选择。

方法二：使用键盘+左键组合（通用替代方案）（未经验证）

如果你不想禁用中键粘贴功能，可以使用组合键来实现矩形选择。

标准快捷键： Shift + Alt + 鼠标左键拖拽。

注意（关于 Alt 键冲突）： 在 Windows 上通常只按 Alt + 左键即可，但在 Linux（尤其是 GNOME 或 KDE 桌面环境）中，Alt + 鼠标左键通常被系统占用为“拖动窗口位置”。

所以，在 Linux 上必须多加一个 Shift 键（即 Shift + Alt + 鼠标左键）。
或者，你也可以去系统设置里把“移动窗口”的快捷键从 Alt 改为 Super (Windows键)，这样在 VS Code 里就可以直接用 Alt + 左键了。

方法三：切换“列选择模式”

如果你需要进行大量的矩形选择操作，可以将编辑器暂时切换为列选择模式。

在顶部菜单栏选择 Selection (选择)。
点击 Column Selection Mode (列选择模式)。
此时，你直接使用鼠标左键拖拽，画出来的就是矩形选区。
操作完成后，再次点击该菜单项取消模式。

快捷键切换： 通常并未绑定默认快捷键，但你可以去键盘快捷方式设置里搜索 toggleColumnSelection 自行绑定。

总结

想恢复鼠标中键拖拽： 请去设置里关闭 Editor: Selection Clipboard。
想保留中键粘贴习惯： 请使用 Shift + Alt + 鼠标左键。

华硕笔记本的一些其他东西

安装 asusctl 和 supergfxctl。（官网https://asus-linux.org/）

由于 asusctl (现更名为 asus-linux 项目的一部分) 和 supergfxctl 官方主要支持 Fedora 和 Arch Linux，Kubuntu/Ubuntu 上没有官方维护的 PPA 源。因此，最稳妥且能用上最新功能的方法是从源码编译安装。

这个过程听起来复杂，但只要按顺序复制粘贴下面的命令即可完成。

准备工作

更新系统并安装基础依赖 打开终端，运行以下命令安装编译所需的工具库：

sudo apt update
sudo apt install -y build-essential git cmake pkg-config libclang-dev libudev-dev libpci-dev libseat-dev libsystemd-dev libglib2.0-dev libgtk-3-dev curl

安装 Rust 编程语言环境 (关键步骤) Ubuntu 仓库里的 Rust 版本通常太旧，编译会报错，所以我们要用官方脚本安装最新版：
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
- 出现提示时，按 1 (默认安装) 并回车。
- 安装完成后，运行以下命令让环境变量立即生效：
```
source "$HOME/.cargo/env"
```

第一步：安装 supergfxctl (显卡切换工具)

这是管理显卡切换的核心工具（必须先装它）。

克隆代码仓库

cd ~
git clone https://gitlab.com/asus-linux/supergfxctl.git
cd supergfxctl

编译并安装
```
make
sudo make install
```
启动服务
```
sudo systemctl enable --now supergfxd.service
```
如果这一步报错，通常是因为没重启，暂时忽略，继续往下走。

第二步：安装 asusctl (整机控制工具)

这是控制风扇、键盘灯、充电限制等功能的工具。

克隆代码仓库

cd ~
git clone https://gitlab.com/asus-linux/asusctl.git
cd asusctl

编译并安装
```
make
sudo make install
```
设置 udev 规则 (非常重要) 为了让普通用户也能控制硬件，需要刷新一下规则：
```
sudo udevadm control --reload-rules && sudo udevadm trigger
```

第三步：安装图形界面 (可选但推荐)

如果你不想每次都敲命令，可以安装 rog-control-center，这是一个图形化界面。

回到 asusctl 目录（如果你刚才退出了的话）
```
cd ~/asusctl
```
注意：rog-control-center 就在 asusctl 的源码包里，不需要单独下载。

编译安装图形界面

make -C rog-control-center
sudo make -C rog-control-center install

第四步：重启与验证

现在，请重启你的电脑！

reboot

重启回来后，进行以下测试：

检查服务状态：
```
systemctl status supergfxd
```
应该显示绿色的 active (running)。
使用命令行切换显卡模式：查看当前模式：
```
supergfxctl -g
```
切换到混合模式（推荐日常使用）：
```
supergfxctl -m Hybrid
```
切换到独显直连/高性能模式（玩游戏用）：
```
supergfxctl -m AsusMuxDgpu
```
(注：切换模式后通常需要注销或重启用户会话)
打开图形界面：在程序菜单里搜索 "ROG Control Center" 并打开。你应该能在里面看到风扇曲线调整、键盘灯光设置以及充电限制（比如设为 80% 保护电池）。

常见问题解决

报错 "Permission denied"：如果你运行 asusctl 命令时提示权限不足，请确保你的用户在 adm 或 users 组里，或者直接使用 sudo。
显卡模式切不过去：确保你已经按照我之前的建议，将 Kubuntu 的电源模式设为 Performance，并且闭源的 NVIDIA 驱动已正确安装。

自动挂载非系统分区

在 Kubuntu (使用 KDE Plasma 桌面) 中，默认情况下确实不会自动挂载非系统分区。要解决这个问题，最简单的方法是使用 KDE 自带的设置，或者使用图形化工具来配置。

以下是三种方法，按推荐程度从高到低排列：

方法一：使用 KDE 系统设置 (最简单，无需修改系统文件)

如果你只是希望登录后自动挂载（不需要在开机未登录时就挂载），这是最安全的方法。

打开 系统设置 (System Settings)。
找到 硬件 (Hardware) -> 可移动存储 (Removable Storage) -> 可移动设备 (Removable Devices)。
- 注意：虽然名字叫“可移动设备”，但通常也能管理内部的其他分区。
勾选 “启用可移动介质的自动挂载” (Enable automatic mounting of removable media)。
在下方的列表中，找到你想要自动挂载的分区。
勾选该分区右侧的 “登录时自动挂载” (On Login) 和 “插入时自动挂载” (On Attach)。
点击 应用 (Apply)。

下次登录时，系统就会自动帮你“点”那一下，分区就挂载好了。

方法二：使用 KDE 分区管理器 (图形化配置，系统级挂载)（未经验证）

如果你希望它是系统级挂载（即开机后无论谁登录，分区都已经挂载好，且挂载路径固定），可以使用自带的工具。

打开应用菜单，搜索并打开 KDE 分区管理器 (KDE Partition Manager) (需要输入密码)。
在左侧选择包含该分区的硬盘。
在右侧列表中，右键点击你要自动挂载的分区，选择 编辑挂载点 (Edit Mount Point)。
- 注意：如果分区处于挂载状态，可能需要先卸载（右键 Unmount）。
在弹出的窗口中：
- 路径 (Path)：选择或输入一个固定的文件夹路径（例如 /mnt/Data 或 /media/你的用户名/Data）。如果不确定，可以保持默认或新建一个。
- 勾选 “如果无法挂载则不阻止系统启动” (Don't prevent system from booting if not mountable) (这很重要，防止硬盘出问题时导致无法开机)。
点击 确定 (OK)，然后点击工具栏左上角的 应用 (Apply) 按钮使更改生效。

方法三：使用 GNOME Disks (界面直观，适合新手)（未经验证）

很多 Kubuntu 用户觉得 KDE 自带的分区管理器设置不够直观，更喜欢用 GNOME 的磁盘工具。

打开终端 (Konsole)，安装它：

sudo apt update
sudo apt install gnome-disk-utility

打开应用菜单，搜索 Disks (磁盘) 并打开。
在左侧选中你的硬盘，在右侧点击你要挂载的分区。
点击分区条下方的 齿轮图标，选择 编辑挂载选项 (Edit Mount Options)。
关闭 “用户会话默认” (User Session Defaults) 的开关。
勾选 “系统启动时挂载” (Mount at system startup)。
点击确定并输入密码。

小提示： 如果不小心配置错误导致开机无法进入桌面（进入了紧急模式），不要惊慌。只需要输入 root 密码，编辑 /etc/fstab 文件，把最后添加的那一行错误的挂载信息删除或注释掉（在行首加 #），保存重启即可。

CPU 锁定 4.7 GHz

使用 TLP 将 CPU 频率锁定在特定数值（例如 4.7GHz），本质上是强制 CPU 始终运行在最高性能状态，不进行降频。

⚠️ 警告：

散热风险：锁定 4.7GHz 会导致 CPU 即使在空闲时也会产生大量热量，风扇可能会狂转。
物理限制：4.7GHz 通常是睿频 (Turbo Boost) 频率。如果散热跟不上，或者达到功耗墙，硬件机制会强制降频（Thermal Throttling），无论软件怎么设置都无法抗拒。

如果确定要这么做，请按照以下步骤操作：

第一步：确认你的 CPU 支持的频率

在配置之前，需要确认 4.7GHz 是有效的频率，并且知道具体的数值单位（通常是 kHz）。

打开终端，输入以下命令查看 TLP 检测到的 CPU 数据：
```
sudo tlp-stat -p
```
查看输出中的 /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies（如果存在）或 scaling_max_freq。
确认 4700000 (kHz) 是否在支持范围内。如果你的 CPU 最大只能到 4.5GHz，强行设 4.7GHz 是无效的。

第二步：修改 TLP 配置文件

我们需要修改 /etc/tlp.conf 文件。

使用文本编辑器打开配置：
```
sudo nano /etc/tlp.conf
```
找到以下几项设置，去掉前面的 # 号（取消注释），并修改数值。 注意：TLP 分为 AC（接电源）和 BAT（用电池）。通常你只会在接电源 (AC) 时锁定高频。

A. 设置调度器为性能模式 (Performance) 这是最关键的一步，告诉内核不要省电。
```
CPU_SCALING_GOVERNOR_ON_AC=performance
```
B. 锁定最小和最大频率 将最小值和最大值都设为 4.7GHz（单位是 kHz，所以是 4700000）。 注意：如果你的 CPU 实际上达不到 4.7G，请填入你查到的最大物理频率。
```
CPU_SCALING_MIN_FREQ_ON_AC=4700000
CPU_SCALING_MAX_FREQ_ON_AC=4700000
```
C. 设置能量性能偏好 (EPP) 对于现代 Intel/AMD CPU，这项设置比 Governor 更重要。
```
CPU_ENERGY_PERF_POLICY_ON_AC=performance
```
D. 确保睿频开启 如果 4.7GHz 属于睿频范围，必须确保 Boost 是开启的。
```
CPU_BOOST_ON_AC=1
```
按下 Ctrl + O 保存，按下 Enter 确认，然后 Ctrl + X 退出编辑器。

第三步：应用更改并验证

应用更改（无需重启电脑）：
```
sudo tlp start
```
验证是否生效：你可以使用 watch 命令实时查看当前 CPU 频率：
```
watch -n 1 "grep \"^[c]pu MHz\" /proc/cpuinfo"
```
或者使用更直观的工具（如果你安装了 s-tui）：
```
s-tui
```

常见问题与排错

如果频率依然在跳动：现代 CPU（特别是 Intel 10代以后）使用 intel_pstate 驱动，它对频率的控制权很大。如果设置了 performance 偏好，它会自动尽可能维持高频，但如果没有任何负载，它可能依然会稍微降频以保护电路。
如果频率卡在基准频率（例如 2.8GHz）上不去：检查散热。如果 CPU 温度过高，BIOS 会强制锁频。
如何恢复默认？ 再次编辑配置文件，把上述修改的行前面加回 #，或者将值改回 balance_performance，然后运行 sudo tlp start。

建议： 比起硬锁 MIN_FREQ=4700000，更好的做法通常是只设置 GOVERNOR=performance 和 EPP=performance。这样 CPU 会极快地响应负载升到 4.7GHz，但在完全无事可做时稍微休息一下，这对硬件寿命更好。

电源模式不见了

省流：装了 TLP 是这样的。

在 Kubuntu (KDE Plasma) 中，电源模式（省电、平衡、性能）的切换选项通常依赖于一个名为 power-profiles-daemon 的后台服务。

Linux 上有一个非常流行的电源管理工具叫 TLP。如果你手动安装了它，或者系统默认包含了它，TLP 会自动禁用 power-profiles-daemon，以此避免两个电源管理程序互相打架。

现象：KDE 电源图标里的滑块不见了，因为 TLP 接管了所有设置。
解决方法：你需要在一个“有界面滑块但控制较少”和“无界面但自动化程度高（TLP）”之间做选择。

如果你想要回 KDE 的电源模式滑块，你需要卸载或禁用 TLP：

打开终端 (Konsole)。
输入以下命令卸载 TLP：
```
sudo apt remove tlp tlp-rdw
```
重新启用 power-profiles-daemon（见方法二）。
重启电脑。

QQ 9 更改存储位置

好像改不了，只能把原来的聊天记录复制过来。具体来说，把原来 Windows 上以 QQ 号命名的文件夹里的 nt_qq 文件夹里的东西，复制到 ~/.config/QQ/nt_qq_一坨你的UUID。

微信 4 打不开

我记得是缺一个依赖，具体是啥我也忘了（

键盘的 F 键指向功能键

临时修改（重启后失效）:

# 设置为 Mac 模式（媒体键优先）
echo 1 > /sys/module/hid_apple/parameters/fnmode

# 设置为 PC 模式（F键优先）
echo 2 > /sys/module/hid_apple/parameters/fnmode

永久修改: 你需要创建一个 modprobe 配置文件。

新建文件: nano /etc/modprobe.d/hid_apple.conf
添加以下内容:
```
options hid_apple fnmode=1
```
(将 1 改为 2 即为强制 F 键优先)
保存并重启，或者重新加载内核模块:
```
update-initramfs -u
```

启动 HMCL 时应用缩放

在启动命令中加入 -Dglass.gtk.uiScale=1.5 参数。参考资料：https://github.com/HMCL-dev/HMCL/discussions/3151

使用 NVIDIA 显卡启动 Minecraft

这是一个非常经典的需求。在 Linux 笔记本（混合显卡）上，为了省电，默认情况下应用程序（包括 Java/Minecraft）都会使用核显（Intel/AMD iGPU）运行。

我们需要显式地告诉系统：“喂，启动这个游戏的时候，把渲染任务交给 NVIDIA 独显去做！”

这主要通过 NVIDIA Prime Render Offload 技术来实现。既然你已经安装了 nvidia-driver-535，这个功能是开箱即用的。

请按照以下步骤操作，最稳妥且方便：

第一步：验证显卡是否准备就绪

先确认 N 卡已经正常工作。在终端输入：

nvidia-smi

如果能看到显卡列表，说明驱动没问题。

第二步：创建一个“独显启动脚本” (prime-run)

为了方便以后任何软件（不只是 HMCL）都能一键调用独显，我们先创建一个通用的命令 prime-run。

打开终端，创建脚本文件：
```
sudo nano /usr/bin/prime-run
```
在里面粘贴以下内容：
```
#!/bin/bash
export __NV_PRIME_RENDER_OFFLOAD=1
export __GLX_VENDOR_LIBRARY_NAME=nvidia
exec "$@"
```
(这段代码的意思是：设置好 NVIDIA 相关的环境变量，然后执行后面跟着的命令)
保存并退出：
- 按 Ctrl + O 回车保存。
- 按 Ctrl + X 退出。
赋予执行权限：
```
sudo chmod +x /usr/bin/prime-run
```

测试一下： 输入 prime-run glxinfo | grep "OpenGL renderer"。如果输出里有 NVIDIA 字样，说明这个命令成功了！

第三步：在 HMCL 中设置

现在我们只需要告诉 HMCL，启动 Java 的时候要在前面加个 prime-run。

打开 HMCL 启动器。
进入 “设置” (Settings) -> “全局游戏设置” (Global Game Settings)（或者你可以针对某个特定整合包单独设置）。
找到 “命令包装” (Wrapper Command) 这一栏（有些版本叫“启动器包装”或类似的）。
在输入框里填入：
```
prime-run
```
关闭设置。

第四步：进游戏验证

通过 HMCL 启动 Minecraft。
进入游戏世界后，按下 F3 键打开调试界面。
看屏幕右侧的信息栏，找到 Display 这一行。
如果成功：你应该能看到类似 NVIDIA GeForce RTX 3060... 的字样。
如果失败：它显示的依然是 Intel UHD Graphics 或 AMD Radeon。

LibreOffice Impress 播放不出视频的解决方法

Tue, 14 Oct 2025 08:06:00 GMT

https://codecguide.com/download_k-lite_codec_pack_basic.htm

下载安装这里的 K-Lite Codec Pack Basic 就可以了。

参考资料： https://wiki.documentfoundation.org/Media_Support/Windows

常量指针和指针常量的区别

Wed, 13 Nov 2024 21:50:00 GMT

指针常量：指针的值是一个常量，不可改变，始终指向同一个地址。
常量指针：指针指向常量，指向的常量不能修改，但指针本身不是一个常量，可以把指针指向别一个常量。

如果const位于*的右侧，则const就是修饰指针本身，即指针本身是常量（指针常量）。如果const位于*的左侧，则const就是修饰指针所指向的变量，即指针指向常量（常量指针）。

可以将常量指针指向非 const 数据，只是不能用常量指针修改该数据的内容。

C++ STL 数据结构模板的运用

Wed, 11 Aug 2021 19:27:00 GMT

本文根据CCF NOI 竞赛大纲的顺序编写。

栈（stack）

栈是一种先进后出的数据结构。使用 STL 的 stack 数据结构需要以下头文件：

#include <stack>

以下是 stack 常用函数（用例中栈名为 $s$）：

函数	语法	用例	作用	类型
`push()`	`栈名.push(元素)`	`s.push(a)`	在栈顶插入新元素	操作
`pop()`	`栈名.pop()`	`s.pop()`	弹出栈顶元素	操作
`top()`	`栈名.top()`	`a = s.top()`	访问栈顶元素	查询
`size()`	`栈名.size()`	`len = s.size()`	查询栈中元素数量	查询
`empty()`	`栈名.empty()`	`f = s.empty()`	查询栈是否为空	查询

队列（queue）

队列是一种先进出的数据结构。使用 STL 的 queue 数据结构需要以下头文件：

#include <queue>

以下是 queue 常用函数（用例中队列名为 $q$）：

函数	语法	用例	作用	类型
`push()`	`队列名.push(元素)`	`q.push(a)`	在队列末端插入新元素	操作
`pop()`	`队列名.pop()`	`q.pop()`	弹出队列头端元素	操作
`front()`	`队列名.front()`	`a = q.front()`	访问队头元素	查询
`back()`	`队列名.back()`	`a = q.back()`	访问队尾元素	查询
`size()`	`队列名.size()`	`len = q.size()`	查询队列中元素数量	查询
`empty()`	`队列名.empty()`	`f = q.empty()`	查询队列是否为空	查询

链表（list）

链表是一种数据结构。使用 STL 的 list 数据结构需要以下头文件：

#include <list>

链表的函数有点多啊，不是我说……

以下是 list 常用函数（用例中链表名为 $l$）（参考了这篇博客）：

函数	语法	用例	作用	类型
`push_front()`	`链表名.push_front(元素)`	`l.push_front(a)`	在链表头端插入新元素	操作
`push_back()`	`链表名.push_back(元素)`	`l.push_back(a)`	在链表尾端插入新元素	操作
`insert()`（1）	`链表名.insert(要插入元素的位置, 元素)`	`l.insert(l.begin(), a)`	在任意位置插入新元素	操作
`insert()`（2）	`链表名.insert(要插入元素的位置, 要插入的数量, 元素)`	`l.insert(l.begin(), 3, a)`	在任意位置插入多个新元素	操作
`insert()`（3）	`链表名.insert(要插入元素的位置, 要插入数据的起始位置, 要插入数据的结束位置)`	`l.insert(l.begin(), v.begin(), v.end())`	插入另一个向量两点之间的数据	操作
`pop_front()`	`链表名.pop_front()`	`l.pop_front()`	弹出链表头端元素	操作
`pop_back()`	`链表名.pop_back()`	`l.pop_back()`	弹出链表尾端元素	操作
`erase()`（1）	`链表名.erase(要删除元素的位置)`	`l.erase(l.end())`	删除任意位置的元素	操作
`erase()`（2）	`链表名.erase(要删除元素的起始位置, 要删除元素的结束位置)`	`l.erase(l.begin(), l.end())`	删除连续多个任意位置的元素	操作
`clear()`	`链表名.clear()`	`l.clear()`	清空所有元素	操作
`assign()`	`链表名.assign(赋值的数量, 要赋的值)`	`l.assign(4, 5)`	为链表赋多个初值	操作
`swap()`（1）	`链表名1.swap(链表名2)`	`l1.swap(l2)`	交换两个链表的值	操作
`swap()`（2）	`swap(链表名1, 链表名2)`	`swap(l1, l2)`	交换两个链表的值	操作
`merge()`	`链表名1.merge(链表名2)`	`l1.merge(l2)`	将一个链表合并入另一个链表，并按照链表的升序排列（注意不是链表中元素的升序）；并将这个链表清空	操作
`splice()`	`链表名1.splice(插入的位置，链表名2)`	`l1.splice(l1.begin(), l2)`	在一个链表的任意位置插入另一个链表；并将这个链表清空	操作
`unique()`	`链表名.unique()`	`l.unique()`	删除链表中相邻的重复元素	操作
`begin()`	`链表名.begin()`	`l.begin()`	链表开始迭代器指针	查询
`end()`	`链表名.end()`	`l.end()`	链表末尾迭代器指针	查询
`cbegin()`	`链表名.cbegin()`	`l.cbegin()`	指向常量的开始迭代器指针	查询
`cend()`	`链表名.cend()`	`l.cend()`	指向常量的末尾迭代器指针	查询
`rbegin()`	`链表名.rbegin()`	`l.rbegin()`	反向迭代器指针，指向最后一个元素	查询
`rend()`	`链表名.rend()`	`l.rend()`	反向迭代器指针，指向第一个元素的前一个元素	查询
`front()`	`链表名.front()`	`a = l.front()`	访问链表头元素	查询
`back()`	`链表名.back()`	`a = l.back()`	访问链表尾元素	查询
`size()`	`链表名.size()`	`len = l.size()`	查询链表中元素数量	查询
`empty()`	`链表名.empty()`	`f = l.empty()`	查询链表是否为空	查询

以下是 list 常用函数（用例中链表名为 $l$）：

遍历元素

list<int>::iterator it;
for (it = lst.begin(); it != lst.end(); it++)
    cout << *it << endl;

元素翻转

#include <algorithm>
reverse(lst.begin(), lst.end());

元素排序

#include <algorithm>
sort(lst.begin(), lst.end()); // 采用的是从小到大的排序

// 如果想从大到小排序，可以采用先排序后反转的方式，也可以采用下面方法:
// 自定义从大到小的比较器，用来改变排序方式
bool Comp(const int& a, const int& b) 
{
    return a > b;
}

sort(lst.begin(), lst.end(), Comp);

向量（vector）

向量是一种数据结构。使用 STL 的 vector 数据结构需要以下头文件：

#include <vector>

以下是 vector 常用函数（用例中向量名为 $l$）：

未完待更……

完了。退役了，更不完了，有人接上这个坑就接上吧，我这给个源码链接，如果有人接上这坑的话回复个链接，我给挂上，就算填了坑了。

源码链接

【题解】P3388 【模板】割点（割顶）

Tue, 20 Apr 2021 22:02:00 GMT

:::note 之前作图的时候没考虑到深色模式，如果您觉得看不清，可以考虑切换到浅色模式，抱歉。 :::

这题搞了我半天……

题意

这题给我们一个图，求这一个图的割点。

首先我们需要了解割点是什么，简单来说就是删除了这个点之后整个图不是连通图。

比如下图中的 $②$ 就是割点*（图片来自OI Wiki）*。

方法

OI Wiki上对割点的讲解：link.

首先用dfs序给每一个节点打上时间戳*（图片来自OI Wiki）*，存在dfn[]数组中：

我们用像求强连通分量一样的 Tarjan 算法遍历每一个节点，用low[]数组存储从这个节点出发能到达的最远古的节点。

我们遍历每一个节点，然后更新节点的low[]值。更新方法：

如果搜索到的下一个节点没有在队列中，搜索完这下一个节点之后，如果这个儿子的low[]值小于自己的low[]值，就将low[]的值更新为它的儿子的low[]值。

本文中程序的v为当前节点，u为循环到的节点。

      tarjan(u, v);                   //找下面这个点
      low[v] = min(low[v], low[u]);   //这个点low[v]的值就是当前low[]的值与找到的u点的low[]值的最小值

还有可能搜到了还在队列中的节点（即自己的祖先），就取low[v]与num[u]的最小值。

else low[v] = min(low[v], num[u]);   //low[v]就取这个点的low值与循环到的点u的dfn[u]的最小值

接下来就要考虑如何发现割点并把发现的割点的数量记录下来。

当找到的点不在队列中时，先更新low[]的值，再判断如果low[u] >= num[v]，即这个点不能回到祖先节点了，

并且此时所在的点不是祖先节点，而且此时所在的点没有被标记过，就 flag[v] = true, res++。

      if (father != v && low[u] >= num[v] && !flag[v]) flag[v] = true, res++; //如果满足割点的条件就标记是割点，并且让答案的个数增加。

另外，如果此时所在的点是祖先节点，并且它有两个及以上的儿子 （只有不在队列中的点才算儿子），而且没被标记过，就 flag[v] = true, res++。

  if (father == v && child >= 2 && !flag[v])    //如果自己有两个儿子并且没有被访问过
                                                //只有不在队列中的点才算儿子。
    flag[v] = true, res++;

上面的儿子可以在遍历每一个节点的时候累加。

代码

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;

inline int read() {
  int X = 0; bool flag = 1; char ch = getchar();
  while (ch < '0' || ch > '9') {if (ch == '-') flag = 0; ch = getchar();}
  while (ch >= '0' && ch <= '9') {X = (X << 1) + (X << 3) + ch - '0'; ch = getchar();}
  if (flag) return X;
  return ~ (X - 1);
}

inline void write(int X) {
  if (X < 0) {putchar('-'); X = ~ (X - 1);}
  int s[50], top = 0;
  while (X) {s[++top] = X % 10; X /= 10;}
  if (!top) s[++top] = 0;
  while (top) putchar(s[top--] + '0');
  putchar(' ');
  return;
}

int head[20004], low[20004], num[20004];
int index, res, cnt;
bool flag[20004], vis[20004];

vector<int> edge[100001];

void tarjan(int v, int father) {      //Tarjan算法
  num[v] = low[v] = ++index;          //标记dfn[]访问顺序，还有low[]的初始值
  vis[v] = true;                      //标记这个点被访问过
  int child = 0;
  for (auto u : edge[v]) {
    if (!vis[u]) {                    //如果u没有被访问过
      child++;
      tarjan(u, v);                   //找下面这个点
      low[v] = min(low[v], low[u]);   //这个点low[v]的值就是当前low[]的值与找到的u点的low[]值的最小值
      if (father != v && low[u] >= num[v] && !flag[v]) flag[v] = true, res++; //如果满足割点的条件就标记是割点，并且让答案的个数增加。
    } else low[v] = min(low[v], num[u]);        //low[v]就取这个点的low值与循环到的点u的dfn[u]的最小值
  }
  if (father == v && child >= 2 && !flag[v])    //如果自己有两个儿子并且没有被访问过
                                                //只有不在队列中的点才算儿子。
    flag[v] = true, res++;
}

int main() {
  int n, m;
  n = read(); m = read();
  for (int i = 1; i <= m; i++) {
    int x, y;
    x = read(); y = read();
    edge[x].push_back(y);
    edge[y].push_back(x);
  }
  for (int i = 1; i <= n; i++) 
    if (!vis[i]) index = 0, tarjan(i, i);
  write(res);
  putchar('\n');
  for (int i = 1; i <= n; i++) if (flag[i]) write(i);
  putchar('\n');
  return 0;
}

数据结构：邻接表

Thu, 08 Apr 2021 19:38:00 GMT

之前我看了很久都没有搞明白邻接表，现在终于差不多搞懂了，特此记录。

那么，邻接表是什么呢？~~邻接表嘛，就是邻接的表。~~

其实邻接表不好理解，主要是开的数组比较多，容易弄混，这一分钟好像弄懂了，下一分钟就不知如何下手了。

那么接下来：

每一个数组的作用

head[点的序号] = 从它出发的最后一次输入的边的编号
from[边的序号] = 边的起点;
to[边的序号] = 边的终点;
nxt[边的序号] = 输入的上一个从这条边的出发点出发的边的编号;
edge[边的序号] = 边的权值

ATTENTION！

next是保留字！
当然也可以使用结构体。
其中除了head[]，数组的下标全部都是边而不是点！
from[]和to[]分别是起点和终点（经常可以不用from[]）；
有的书上的ver[]（如《算法竞赛进阶指南》）就是这里的to[]。

add()函数

使用邻接表存图的时候，用到的add()函数：

void add(int x, int y, int z) {
    to[++tot] = y, edge[tot] = z; //edge为边的权值，可视情况而用
    nxt[tot] = head[x], head[x] = tot;
}

好好理解一下，反正我一开始就是卡在“每一个数组的作用”这里。

【题解】P3387 【模板】缩点

Thu, 08 Apr 2021 15:19:00 GMT

题目链接：【模板】缩点

前言

这是一道模板题。需要学习强连通分量和缩点，还有最短路径算法。

审题

给一张图，找一条路径使点权和最大。

思路

先用tarjan算法求出这张图中所有的强连通分量，将它们缩成一点，建一个缩点后的图。这次题目让我们求这张图上的一条路径，使经过的点权之和最大。看到“最”，就会想到和最短路有关。但是这题求的是最大的点权之和，就需要考虑把最短路算法魔改一下。

这篇题解使用的是LPFA算法~~（Longest Path Fast Algorithm，发明者：沃·兹基硕德）~~

把SPFA算法的边权改为点权，松弛改为扩张：

  if (dis[v] > dis[u] + siz[v]) dis[v] = dis[u] + siz[v];
->if (dis[v] < dis[u] + siz[v]) dis[v] = dis[u] + siz[v];

整个LPFA的代码如下：

void spfa(int s) {          //LPFA开始
  queue<int> que;           //定义队列que
  que.push(s);              //将s push进队列
  dis[s] = siz[s];          //将s出发的最长路的值初始化为它所在连通块的权值之和
  used[s] = true;           //标记s在队列中
  while (!que.empty()) {    //当队列不为空（即有值）时循环
    int u = que.front();    //把u赋为que的队首元素
    que.pop();              //删除que中的第一个元素
    used[u] = false;        //标记u不在队列中
    for (int i = head[u]; ~i; i = edge[i].next) {  //循环从u出发的所有边
      int v = edge[i].to;                //定义点v并把它赋值为这条边的终点
      if (dis[v] < dis[u] + siz[v]) {    //如果现在的“最长路”没有先走u的长度长
	dis[v] = dis[u] + siz[v];        //就对路径进行“扩张”操作
	if (!used[v]) {                  //如果点v不在队列中
	  used[v] = true;                //标记它加入队列
	  que.push(v);                   //把它加入队列
	}
      }
    }
  }
  for (int i = 1; i <= sccnt; i++)       //循环每一个强连通分量，找dis（最长路）的最大值
    ans = max(ans, dis[i]);              //如果dis[i]比答案大，就让答案为dis[i]
}

因为需要求出权值的最大和，所以tarjan函数里面多了这样一句：

siz[sccnt] += val[u];

整个tarjan()函数如下

void tarjan(int v) {       //Tarjan算法
  dfn[v] = low[v] = ++tot; //标记dfn[]访问顺序，还有low[]的初始值
  sta.push(v);             //让点v进栈
  vis[v] = true;           //标记这个点被访问过
  for (int i = head[v]; ~i; i = edge[i].next) { //一直循环这个点每一个出度，直到-1表示没有了，这也是为什么memset head数组时要赋-1
    int u = edge[i].to;               //定义u并把它赋成这条边的终点
    if (!dfn[u]) {                    //如果u没有被访问过
      tarjan(u);                      //找下面这个点
      low[v] = min(low[v], low[u]);   //这个点low[v]的值就是当前low[]的值与找到的u点的low[]值
    } else if (vis[u])                //如果u被访问过了，但是还在队列中
      low[v] = min(low[v], dfn[u]);   //low[v]就取这个点的low值与循环到的点u的dfn[u]的最小值
  }
  if (dfn[v] == low[v]) {   //如果发现v这个点的dfn[]和low[]相等，说明这个点是一个强连通分量的“根”。
    sccnt++;                //scc（Strongly Connected Component）， cnt（count），就是强连通分量的个数
    int u;                  //定义u变量，作为栈顶元素
    do { 
      u = sta.top();        //将u赋值为sta栈的栈顶元素
      vis[u] = false;       //将u弹出
      sta.pop();            //同上
      color[u] = sccnt;     //将u标记为这个强连通分量里的点
      siz[sccnt] += val[u]; //这个强连通分量的权值加上u这个点的权值
    } while (v != u);       //当v == u之后，结束循环
  }
}

为了使每一个点都被访问到，tarjan()的调用在循环中进行：

  for (int i = 1; i <= n; i++) //循环每一个点
    if (!dfn[i]) tarjan(i);    //如果dfn[i]没有值，即这个点被没有访问过，需要访问；
                               //如果dfn[i]已经有一个值，说明这个点被访问过了，不用担心漏了，
                               //同时也为了节省时间，就不访问了。

建缩点后的图时，将原来的head[]和edge[]数组清空，循环每一条边，如果它的起点和终点不在一个强连通分量中，则连一条边：

  for (int i = 1; i <= m; i++)              //循环每一条边
    if (color[from[i]] != color[to[i]])     //如果这条边的出发点和终止点不在同一个强连通分量中
      add(color[from[i]], color[to[i]]);    //就连一条边

代码

完整代码如下：

#include <bits/stdc++.h>   //万能头文件
using namespace std;       //名字空间，具体我也不知有啥用，但是有用到了iostream就得加这个，否则就得std::
const int maxN = 2e5 + 3;  //数组大小

struct Edge {
  int next, to;            //用结构体存邻接表
} edge[maxN];
int head[maxN], dfn[maxN], low[maxN];
int color[maxN], val[maxN], siz[maxN];
int from[maxN], to[maxN], dis[maxN];
bool vis[maxN], used[maxN];
int cnt, tot, sccnt, ans, n, m;
stack<int> sta;

//以上定义了一包变量和数组

template<typename Tp> void read(Tp &x) {
  char c = getchar();      //先输入一个字符
  x = 0;                   //定义x并初始化为0，用来累计输入的数
  while (!isdigit(c)) c = getchar(); //如果这个字符不是数字的话，就一直读下一个字符（本题没有负数情况）
  do {
    x = x * 10 + (c ^ 48); //先把x×10，然后与c^48相加
                           //十进制48转换为二进制为110000，而'0'到'9'都是11****，异或会使不同的位为1，相同的位为0
    c = getchar();         //读下一个字符
  } while (isdigit(c));    //循环条件为读到的为数字，则一直循环到读入的不是数字为止
}

void add(int from, int to) {
  edge[++cnt].next = head[from], edge[cnt].to = to, head[from] = cnt;
}

void tarjan(int v) {       //Tarjan算法
  dfn[v] = low[v] = ++tot; //标记dfn[]访问顺序，还有low[]的初始值
  sta.push(v);             //让点v进栈
  vis[v] = true;           //标记这个点被访问过
  for (int i = head[v]; ~i; i = edge[i].next) { //一直循环这个点每一个出度，直到-1表示没有了，这也是为什么memset head数组时要赋-1
    int u = edge[i].to;               //定义u并把它赋成这条边的终点
    if (!dfn[u]) {                    //如果u没有被访问过
      tarjan(u);                      //找下面这个点
      low[v] = min(low[v], low[u]);   //这个点low[v]的值就是当前low[]的值与找到的u点的low[]值
    } else if (vis[u])                //如果u被访问过了，但是还在队列中
      low[v] = min(low[v], dfn[u]);   //low[v]就取这个点的low值与循环到的点u的dfn[u]的最小值
  }
  if (dfn[v] == low[v]) {   //如果发现v这个点的dfn[]和low[]相等，说明这个点是一个强连通分量的“根”。
    sccnt++;                //scc（Strongly Connected Component）， cnt（count），就是强连通分量的个数
    int u;                  //定义u变量，作为栈顶元素
    do { 
      u = sta.top();        //将u赋值为sta栈的栈顶元素
      vis[u] = false;       //将u弹出
      sta.pop();            //同上
      color[u] = sccnt;     //将u标记为这个强连通分量里的点
      siz[sccnt] += val[u]; //这个强连通分量的权值加上u这个点的权值
    } while (v != u);       //当v == u之后，结束循环
  }
}
void spfa(int s) {          //LPFA开始
  queue<int> que;           //定义队列que
  que.push(s);              //将s push进队列
  dis[s] = siz[s];          //将s出发的最长路的值初始化为它所在连通块的权值之和
  used[s] = true;           //标记s在队列中
  while (!que.empty()) {    //当队列不为空（即有值）时循环
    int u = que.front();    //把u赋为que的队首元素
    que.pop();              //删除que中的第一个元素
    used[u] = false;        //标记u不在队列中
    for (int i = head[u]; ~i; i = edge[i].next) {  //循环从u出发的所有边
      int v = edge[i].to;                //定义点v并把它赋值为这条边的终点
      if (dis[v] < dis[u] + siz[v]) {    //如果现在的“最长路”没有先走u的长度长
	dis[v] = dis[u] + siz[v];        //就对路径进行“扩张”操作
	if (!used[v]) {                  //如果点v不在队列中
	  used[v] = true;                //标记它加入队列
	  que.push(v);                   //把它加入队列
	}
      }
    }
  }
  for (int i = 1; i <= sccnt; i++)       //循环每一个强连通分量，找dis（最长路）的最大值
    ans = max(ans, dis[i]);              //如果dis[i]比答案大，就让答案为dis[i]
}
int main() {
  memset(head, -1, sizeof(head));            //把head[]数组初始化为-1，具体原因见tarjan函数
  read(n), read(m);                          //输入n、m
  for (int i = 1; i <= n; i++) read(val[i]); //输入每一个点的权值
  for (int i = 1; i <= m; i++) {
    read(from[i]), read(to[i]);              //输入每一条边的起点和重点
    add(from[i], to[i]);                     //把起点和终点连一条边
  }
  for (int i = 1; i <= n; i++) //循环每一个点
    if (!dfn[i]) tarjan(i);    //如果dfn[i]没有值，即这个点被没有访问过，需要访问；
                               //如果dfn[i]已经有一个值，说明这个点被访问过了，不用担心漏了，
                               //同时也为了节省时间，就不访问了。
  memset(head, -1, sizeof(head));           //将原来的head[]数组清空，以便重新建图
  memset(edge, 0, sizeof(edge));            //将原来的edge[]数组清空，以便重新建图
  for (int i = 1; i <= m; i++)              //循环每一条边
    if (color[from[i]] != color[to[i]])     //如果这条边的出发点和终止点不在同一个强连通分量中
      add(color[from[i]], color[to[i]]);    //就连一条边
  for (int i = 1; i <= sccnt; i++) spfa(i); //循环每一个连通块（单独的一个点也是一个连通块），因为每一个连通块已经缩成一个点，所以就可以当作一个点来对待
  printf("%d\n", ans);                      //输出答案
}

全网最最详细！一文讲懂Tarjan算法求强连通分量 & 缩点

Thu, 08 Apr 2021 14:46:00 GMT

网上看了几篇博客，还有OI Wiki，觉得整合度不够，于是特意写了篇博客。

参考资料

全网最!详!细!Tarjan算法讲解。强连通分量(SCC)与缩点强连通分量 - OI Wiki

正文

在学习强连通分量和缩点之前，请务必理解邻接表。

以下有OI Wiki的内容，有大佬博客里的内容，也有我自己的内容。

强连通分量

引入

强连通的定义是：有向图 G 强连通是指，G 中任意两个结点连通。 强连通分量（Strongly Connected Components，简称SCC）的定义是：极大的强连通子图。

举一个简单的例子。下面是一个有向图。

在这个图中， 1和2互相有路径可以到达对方，所以这两个点强连通； 1、2和3中任意两个点都连通，它们是这整个有向图的强连通分量。

求强连通分量。

下面我们介绍使用Tarjan算法求强连通分量。

我们举个例子说明这个算法是怎么运作的。图片取自《算法竞赛进阶指南》。

从 $①$ 进入，dfn[1] = low[1] = ++index == 1 入栈 $①$，此时的栈中元素为 $①$，vis[1] = true，即点 $①$ 在栈中。

往下找到 $②$，dfn[2] = low[2] = ++index == 2 入栈 $②$，此时栈中元素为 $①②$，vis[2] = true

继续往下找到 $③$，dfn[3] = low[3] = ++index == 3 入栈 $③$，此时栈中元素为 $①②③$，vis[3] = true

继续往下找到 $④$，dfn[4] = low[4] = ++index == 4 入栈 $④$，此时栈中元素为 $①②③④$，vis[4] = true

继续往下找到 $⑤$，dfn[5] = low[5] = ++index == 5 入栈 $5$，此时栈中元素为 $①②③④⑤$，vis[5] = true

继续往下找到 $②$ 他太爷爷，dfn[2]被访问过并且还在栈中，说明这个 $②$ 还在这个强连通分量中，值得发现。low[5] = min(low[5], dfn[2]) 确定关系：$⑤$ 节点比 $②$ 节点出现得晚，即low[5] > dfn[2]，所以 $⑤$ 是 $①$ 的子节点；low[5] = 2

然后发现 $⑤$ 这个点没有出边了，返回到 $④$ 这个点。于是low[4] = min(low[4], low[5]) = 2

$④$ 这个点也没有出边了，返回到 $③$ 这个点。于是low[3] = min(low[3], low[4]) = 2

$③$ 这个点也没有出边了，返回到 $②$ 这个点。于是low[2] = min(low[2], low[2]) = 2，对没错，还是2

$②$ 也没有出边，但是这时我们会发现low[2] == dfn[2] == 2，这就是说，点 $②$ 是这个强连通分量的根，于是sccnt++（sccnt：强连通分量的个数），一直弹出栈顶元素，并把栈顶元素的颜色标记为sccnt（color[2] = sccnt），直到栈顶元素为2时最后弹出一次并标记颜色。此时栈中元素为 $①$，vis[5] = vis[4] = vis[3] = vis[2] = false。

返回到 $①$。因为 $①$ 比 $②$ 出现得早，即low[1] < low[2]，所以low[1]的值没变，还是1

点 $①$ 还有出边，继续往下找到 $⑤$。嗯？dfn[5]已经有一个值5了，再看vis[5] == false，说明 $⑤$ 这个点已经不在栈中了，所以low[1] = min(low[1], dfn[5]) = 1（因为low[1] == 1，dfn[5] == 2）

~~唉，现在同学都在准备省选，要不是我去年NOIP第一题用了邻接矩阵，数组开得太大了，我也去参加省选了（看出我有多蒻了吧）~~

点 $①$ 还有出边，继续往下找找到 $⑥$，dfn[6] = low[6] = ++index == 6 入栈 $⑥$，此时栈中元素为 $①⑥$ ，vis[6] = true

继续往下找到 $⑦$，dfn[7] = low[7] = ++index = 7 入栈 $⑦$，此时栈中元素为 $①⑥⑦$，vis[7] = true

继续往下找到 $④$，发现dfn[4] == 4，说明 $④$ 已经被访问过了，又因为vis[4] == false，也就是 $④$ 不在栈中，就不用管它。

$⑦$ 没有别的出边了。判断此时dfn[7] == low[7] == 7，所以 $⑦$ 是一个强连通分量的根。于是：Ⅰ：sccnt++；Ⅱ：把栈顶元素（即 $⑦$ 的颜色标记为sccnt），将其弹出。此时栈中元素为 $①⑥$。

返回到 $⑥$，找到点 $⑧$，dfn[8] = low[8] = ++index = 8 入栈 $⑧$，此时栈中元素为 $①⑥⑧$，vis[8] = true

往下找到 $⑦$，发现dfn[7] == 7，说明 $⑦$ 已经被访问过了，又因为vis[7] ==false，$⑦$ 不在栈中，不用管。

回到 $⑧$，它还有一条出边到 $⑨$，dfn[9] = low[9] = ++index = 9 入栈 $⑨$，此时栈中元素为 $①⑥⑧⑨$，vis[9] = true

再往下找到 $⑥$，找到了他爷爷（他爸是 $⑧$），dfn[6]被访问过并且还在栈中，说明这个 $⑥$ 还在这个强连通分量中。low[9] = min(low[9], dfn[6]) = 6。

接着就是： low[8] = min(low[8], low[9]) = 6 low[6] = min(low[6], low[8]) = 6

此时 $⑥$ 的出边已经找完了，又因为low[6] == dfn[6] == 6，所以 $⑥$ 是强连通分量的根，sccnt++，一直弹出栈顶元素，将栈顶元素颜色标记为sccnt，直到栈顶元素为6，最后弹出一次，标记颜色。此时栈中元素为 $①$，vis[9] = vis[8] = vis[6] = false。

返回到 $①$，$①$的出边也已经找完了，因为low[1] == dfn[1] == 1，所以 $①$ 是强连通分量的根，sccnt++，弹出栈顶元素（1），将栈顶元素颜色标记为sccnt。此时栈为空，vis[1] = false。

这个时候就完了吗？！你以为就完了吗？！然而并没有完，万一只走了一遍tarjan整个图没有找完怎么办呢？！所以。tarjan的调用要在循环里解决，以使每一个点都被访问到。

代码

下面是tarjan函数的代码：

void tarjan(int v) {       //Tarjan算法
  dfn[v] = low[v] = ++tot; //标记dfn[]访问顺序，还有low[]的初始值
  sta.push(v);             //让点v进栈
  vis[v] = true;           //标记这个点被访问过
  for (int i = head[v]; ~i; i = edge[i].next) { //一直循环这个点每一个出度，直到-1表示没有了，这也是为什么memset head数组时要赋-1
    int u = edge[i].to;               //定义u并把它赋成这条边的终点
    if (!dfn[u]) {                    //如果u没有被访问过
      tarjan(u);                      //找下面这个点
      low[v] = min(low[v], low[u]);   //这个点low[v]的值就是当前low[]的值与找到的u点的low[]值
    } else if (vis[u])                //如果u被访问过了，但是还在队列中
      low[v] = min(low[v], dfn[u]);   //low[v]就取这个点的low值与循环到的点u的dfn[u]的最小值
  }
  if (dfn[v] == low[v]) {   //如果发现v这个点的dfn[]和low[]相等，说明这个点是一个强连通分量的“根”。
    sccnt++;                //scc（Strongly Connected Component）， cnt（count），就是强连通分量的个数
    int u;                  //定义u变量，作为栈顶元素
    do { 
      u = sta.top();        //将u赋值为sta栈的栈顶元素
      vis[u] = false;       //将u弹出
      sta.pop();            //同上
      color[u] = sccnt;     //将u标记为这个强连通分量里的点
    } while (v != u);       //当v == u之后，结束循环
  }
}

在主函数里像这样调用tarjan函数：

  for (int i = 1; i <= n; i++) //循环每一个点
    if (!dfn[i]) tarjan(i);    //如果dfn[i]没有值，即这个点被没有访问过，需要访问；
                               //如果dfn[i]已经有一个值，说明这个点被访问过了，不用担心漏了，
                               //同时也为了节省时间，就不访问了。

缩点

引入

缩点的定义：把强连通分量看成是一个大点，保留那些不在强连通分量里的边，这样的图就是缩点后的图。缩点后的图保留了所有不在分量里的边，而且缩点后的图是一个有向无环图（DAG），可以进行拓扑排序。

那么，缩点之后的图，就成了这样：

缩点的解决

现在问题来了，怎么储存缩点后的图？

在一开始调用的tarjan函数中，我们已经把同一个强连通分量中的点标记成了相同的颜色。为了重新建立一个缩点后的图，我们先把head[]数组和edge[]数组清空，在读入边的时候，我们把边的起点和终点分别存到from[]数组和to[]数组中。在建立邻接表储存缩点后的图时，判断这些输入的点是否在同一个 SCC 中，如果不在就连边。用如下代码建立缩点后的图：

  for (int i = 1; i <= m; i++)              //循环每一条边
    if (color[from[i]] != color[to[i]])     //如果这条边的出发点和终止点不在同一个强连通分量中
      add(color[from[i]], color[to[i]]);    //就连一条边

【模板】缩点

题目链接：【模板】缩点

审题

这题不仅需要缩点，还要找出一条路径使点权和最大。因为强连通分量（SCC）中点可以互相到达，所以需要缩点使图变成一个有向无环图（DAG），强连通分量内所有点权和即为缩点后该点的点权。这题可以使用LPFA算法~~（Longest Path Fast Algorithm，发明者：沃·兹基硕德）~~来解决。把松弛改为扩张：

  if (dis[v] > dis[u] + siz[v]) dis[v] = dis[u] + siz[v];
->if (dis[v] < dis[u] + siz[v]) dis[v] = dis[u] + siz[v];

代码

详情请见【题解】P3387 【模板】缩点

【题解】LibreOJ #6279. 数列分块入门 3

Mon, 05 Apr 2021 21:50:00 GMT

题目链接：LibreOJ #6279. 数列分块入门 3

题面

题目描述

给定一个长为 $n$ 的数列，以及 $n$ 个操作，操作涉及区间加法，询问区间内小于某个值 $x$ 的前驱（比其小的最大元素）。

输入格式

第一行输入一个数字 $n$。

第二行输入 $n$ 个数字，第 $i$ 个数字为 $a_i$，以空格隔开。

接下来输入 $n$ 行询问，每行输入四个数字 $\rm{opt}、l、r、c$，以空格隔开。

若 $\rm opt=0$，表示将位于 $\left[l, r\right]$ 的之间的数字都加 $c$。

若 $\rm opt=1$，表示询问 $\left[l, r\right]$ 中 $c$ 的前驱的值（不存在则输出 $\rm -1$）。

输出格式

对于每次询问，输出一行一个数字表示答案。

样例（很水）

Input

Output

3
-1

数据范围与提示

对于 $100%$ 的数据，$1\leq n\leq 100000,-2^{31}\leq {\rm others}$、${\rm ans}\leq 2^{31}-1$。

对题目的吐槽

这个样例是真的水，从样例中根本找不出自己程序任何错误。。。。

我一开始程序内层循环用的是i变量，样例居然给我过了？！

思路

审题

这道题他说要求前驱的值。要求前驱的值如果直接暴力查找的话肯定会T飞，所以需要用到分块来优化。

解法

加c的核心代码如下：

for (int j = x; j <= r[b[x]]; j++) a[j] += k;         //左边不完整块暴力相加
for (int j = l[b[x]]; j <= r[b[x]]; j++) d[j] = a[j]; //将a[]数组复制一份给d[]数组，以此来达到将数组排序而不破坏原数组顺序
sort(d + l[b[x]], d + r[b[x]] + 1);                   //将d[]数组排序
for (int j = l[b[y]]; j <= y; j++) a[j] += k;         //右边不完整块暴力相加
for (int j = l[b[y]]; j <= r[b[y]]; j++) d[j] = a[j]; //将a[]数组复制一份给d[]数组，以此来达到将数组排序而不破坏原数组顺序
sort(d + l[b[y]], d + r[b[y]] + 1);                    //将d[]数组排序
for (int j = b[x] + 1; j <= b[y] - 1; j++)  lazy[j] += k; //用lazyp[]数组对中间完整块做标记，减少运算量

查询的核心代码如下：

for (int j = x; j <= r[b[x]]; j++) //暴力查询左边不完整块
  if ((lazy[b[x]] + a[j] < k) && (lazy[b[x]] + a[j] > maxx)/*需要保证这个比k小并且比maxx大*/)
    maxx = lazy[b[x]] + a[j]; 
for (int j = l[b[y]]; j <= y; j++) //暴力查询右边不完整块
  if ((lazy[b[y]] + a[j] < k) && (lazy[b[y]] + a[j] > maxx))
    maxx = lazy[b[y]] + a[j];
for (int j = b[x] + 1; j <= b[y] - 1; j++) {
  if (k - lazy[j] <= d[(j - 1) * block + 1]) continue;
  int num = lower_bound(d + l[j], d + r[j] + 1, k - lazy[j]) - d - 1; 
  //lower_bound函数返回的是大于或等于k - lazy[j]的第一个数的地址（指针），减去d可得数组下标，再减一即可得到前驱
  maxx = maxx > (d[num] + lazy[j]) ? maxx : (d[num] + lazy[j]);
}
if (maxx == -1) write(-1); //如果maxx没变（即没找到），则输出-1
else write(maxx); //否则输出maxx（前驱）

代码

这次的代码是LibreOJ格式化过的，总觉得有亿点奇怪

#include <iostream>
#include <algorithm> //sort()要用
#include <cstdio>
#include <cmath> //sqrt()y要用
#define int long long
using namespace std;

int a[1000005], d[1000005], l[1005], r[1005], b[1000005], lazy[1005];
int n, q, block, tot, x, y, k;
int c;

inline int read() { //快读
    int X = 0;
    bool flag = 1;
    char ch = getchar();

    while (ch < '0' || ch > '9') {
        if (ch == '-')
            flag = 0;

        ch = getchar();
    }

    while (ch >= '0' && ch <= '9') {
        X = (X << 1) + (X << 3) + ch - '0';
        ch = getchar();
    }

    if (flag)
        return X;

    return ~(X - 1);
}

inline void write(int X) { //快写
    if (X < 0) {
        putchar('-');
        X = ~(X - 1);
    }

    int s[50], top = 0;

    while (X) {
        s[++top] = X % 10;
        X /= 10;
    }

    if (!top)
        s[++top] = 0;

    while (top)
        putchar(s[top--] + '0');

    putchar('\n');
    return;
}


signed main() {
    n = read();

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

    block = sqrt(n), tot = n / block;

    if (n % block)
        tot++; //如果数的个数不是块长的倍数的话，还要再增加一个块的个数

    for (int i = 1; i <= n; i++)
        b[i] = (i - 1) / block + 1, d[i] = a[i];

    for (int i = 1; i <= tot; i++)
        l[i] = (i - 1) * block + 1, r[i] = i * block;

    r[tot] = n;

    for (int i = 1; i <= tot; i++)
        sort(d + l[i], d + r[i] + 1);

    for (int i = 1; i <= n; i++) {
        c = read();
        x = read();
        y = read();
        k = read();

        if (c == 0) {
            if (b[x] == b[y]) { //如果x和y在同一个块内，就直接只能暴力相加
                for (int j = x; j <= y; j++)
                    a[j] += k;

                for (int j = l[b[x]]; j <= r[b[x]]; j++)
                    d[j] = a[j];

                sort(d + l[b[x]], d + r[b[x]] + 1);
            } else {
                for (int j = x; j <= r[b[x]]; j++) //左边不完整块暴力相加
                    a[j] += k;

                for (int j = l[b[x]]; j <= r[b[x]]; j++) //将a[]数组复制一份给d[]数组，以此来达到将数组排序而不破坏原数组顺序
                    d[j] = a[j];

                sort(d + l[b[x]], d + r[b[x]] + 1); //将d[]数组排序

                for (int j = l[b[y]]; j <= y; j++) //右边不完整块暴力相加
                    a[j] += k;

                for (int j = l[b[y]]; j <= r[b[y]]; j++) //将a[]数组复制一份给d[]数组，以此来达到将数组排序而不破坏原数组顺序
                    d[j] = a[j];

                sort(d + l[b[y]], d + r[b[y]] + 1); //将d[]数组排序

                for (int j = b[x] + 1; j <= b[y] - 1; j++) //用lazyp[]数组对中间完整块做标记，减少运算量
                    lazy[j] += k;
            }
        }

        if (c == 1) {
            int maxx = -1;

            if (b[x] == b[y]) { //如果x和y在同一个块内，就直接只能暴力求解
                for (int j = x; j <= y; j++)
                    if ((lazy[b[x]] + a[j] < k) && (lazy[b[x]] + a[j] > maxx))
                        maxx = lazy[b[x]] + a[j];

                if (maxx == -1)
                    write(-1);
                else
                    write(maxx);
                continue;
            } else {
                for (int j = x; j <= r[b[x]]; j++) //暴力查询左边不完整块
                    if ((lazy[b[x]] + a[j] < k) && (lazy[b[x]] + a[j] > maxx))
                        maxx = lazy[b[x]] + a[j];
                for (int j = l[b[y]]; j <= y; j++) //暴力查询右边不完整块
                    if ((lazy[b[y]] + a[j] < k) && (lazy[b[y]] + a[j] > maxx))
                        maxx = lazy[b[y]] + a[j];
                for (int j = b[x] + 1; j <= b[y] - 1; j++) {
                    if (k - lazy[j] <= d[(j - 1) * block + 1])
                        continue;
                    int num = lower_bound(d + l[j], d + r[j] + 1, k - lazy[j]) - d - 1;
                    //lower_bound函数返回的是大于或等于k - lazy[j]的第一个数的地址（指针），减去d可得数组下标，再减一即可得到前驱
                    maxx = (maxx > (d[num] + lazy[j])) ? maxx : (d[num] + lazy[j]);
                }
                if (maxx == -1) //如果maxx没变（即没找到），则输出-1
                    write(-1);
                else
                    write(maxx); //否则输出maxx（前驱）
            }
        }
    }

    return 0;
}

【题解】LibreOJ #6281. 数列分块入门 5

Mon, 05 Apr 2021 11:05:00 GMT

题目链接：LibreOJ #6281. 数列分块入门 5

题面

题目描述

给定一个长为 $n$ 的数列 $a_1\dots a_n$，以及 $n$ 个操作，操作涉及区间开方，区间求和。

输入格式

第一行输入一个数字 $n$。

第二行输入 $n$ 个数字，第 $i$ 个数字为 $a_i$，以空格隔开。

接下来输入 $n$ 行询问，每行输入四个数字 $\rm{opt},l,r,c$，以空格隔开。

若 $\rm opt=0$，表示将位于 $\left[l, r\right]$ 的之间的数字都开方。对于区间中每个 $a_i\left(l\leq i\leq r\right)\longleftarrow \lfloor \sqrt a_i \rfloor$

若 $\rm opt=1$，表示询问位于 $\left[l, r\right]$ 的所有数字的和。

输出格式

对于每次询问，输出一行一个数字表示答案。

样例（很水）

Input

Output

6
2

数据范围与提示

对于 $100%$ 的数据，$1\leq n\leq 50000,-2^{31}\leq {\rm others}$、${\rm ans}\leq 2^{31}-1$。

写博客时的吐槽

$\rm \LaTeX$是真nm难打啊。。

思路

审题

与平时最简单的数列分块入门的区别在于，这个数列分块入门五并不是加上or减去一个数，而是开方。这两者的区别在于，加上或者减去一个数与这个数本身无关，可以直接相加减，可以直接做记号表示这个块加上或减去了某个数。

加上或减去某个数时，在完整块中，这一个块每一个数增加或减少的值都相同，就可以很容易地给这一整个块做标记。

但是做开方运算时（其实乘方、乘除都很坑），每一个块增加或者减小的值不相等，就导致了不能把这一整个块增加或减小的值做一个标记，这就相当于把分块废掉了。

解法

这是一道题目，总不可能没有解法吧。

我们用到了下面这个$\rm sol()$函数来解决这个问题。

void sol(int x) {
  if (flag[x]) return; //如果这个块被标记了，就废了，直接返回，节省时间
                       //标记原则后面会讲
  flag[x] = true;      //先把这个块标记
  sum[x] = 0;          //将sum[]数组初始化为零
  for (int i = (x - 1) * len + 1; i <= x * len; i++) { //循环块内每一个值
    a[i] = sqrt(a[i]), sum[x] += a[i]; //对块内每一个数都做开方运算，再把他们的和存进sum[]数组里面
    if (a[i] > 1) flag[x] = false;     //如果这一个值还大于1，也就是还能够进行开方，这个块就还能继续开放，把flag[]标记去除
  }
  return;
}

从上面的函数中可以看出，我们把已经不能再开方的块进行跳过，大大节约了程序开方的时间。这就是代码的关键。

剩下的地方就和普通的数列分块差不多了。

代码

#include <cstdio> //getchar()和putchar()要用
#include <cmath>  //取块大小和开方时需要用到sqrt()函数

int b[50005], a[50005], sum[255];
bool flag[255];
int len;

int read() {//快速读入，因为LibreOJ默认吸氧，所以没有了前面的inline
  int X = 0; bool flag = 1; char ch = getchar();
  while (ch < '0' || ch > '9') {if (ch == '-') flag = 0; ch = getchar();}
  while (ch >= '0' && ch <= '9') {X = (X << 1) + (X << 3) + ch - '0'; ch = getchar();}
  if (flag) return X;
  return ~ (X - 1);
}

void write(int X) {//快速输出，同上
  if (X < 0) {putchar('-'); X = ~ (X - 1);}
  int s[50], top = 0;
  while (X) {s[++top] = X % 10; X /= 10;}
  if (!top) s[++top] = 0;
  while (top) putchar(s[top--] + '0');
  putchar('\n');
  return;
}

void sol(int x) {
  if (flag[x]) return; //如果这个块被标记了，就废了，直接返回，节省时间
  flag[x] = true;      //先把这个块标记
  sum[x] = 0;          //将sum[]数组初始化为零
  for (int i = (x - 1) * len + 1; i <= x * len; i++) { //循环块内每一个值
    a[i] = sqrt(a[i]), sum[x] += a[i]; //对块内每一个数都做开方运算，再把他们的和存进sum[]数组里面
    if (a[i] > 1) flag[x] = false;     //如果这一个值还大于1，也就是还能够进行开方，这个块就还能继续开放，把flag[]标记去除
  }
  return;
}

void add(int l, int r) {
  for (int i = l; i <= (b[l] * len < r ? b[l] * len : r); i++) { //从左往右暴力循环左侧不完整块
    sum[b[l]] -= a[i];
    a[i] = sqrt(a[i]);
    sum[b[l]] += a[i];
  }
  if (b[l] != b[r]) //如果l和r不在同一块内
    for (int i = r; b[i] == b[r]; i--) { //同右往左暴力循环右侧不完整块
	//循环条件这里我原来一直写i == b[r]就错了，要注意，下面query()函数也是
      sum[b[r]] -= a[i];
      a[i] = sqrt(a[i]);
      sum[b[r]] += a[i];
    }
  for (int i = b[l] + 1; i <= b[r] - 1; i++) sol(i); //中间完整块使用sol()函数解决
  return;
}

int query(int l, int r) { //查询函数，与普通分块差不多
  int ans = 0;
  for (int i = l; i <= (b[l] * len < r ? b[l] * len : r); i++) ans += a[i];//左侧
  if (b[l] != b[r]) for (int i = r; b[i] == b[r]; i--) ans += a[i];//右侧
  for (int i = b[l] + 1; i <= b[r] - 1; i++) ans += sum[i];//中间
  return ans;
}

int main() {
  int n;
  n = read();
  len = sqrt(n);
  for (int i = 1; i <= n; i++) a[i] = read();
  for (int i = 1; i <= n; i++) {
    b[i] = (i - 1) / len + 1;
    sum[b[i]] += a[i];
  }
  for (int i = 1; i <= n; i++) {
    bool opt; int l, r;
    opt = read(); l = read(); r = read(); read();
    opt ? write(query(l, r)) : add(l, r);
    //三目运算符，如果opt==1就add()，else就query()
  }
  return 0;
}

NOI Online 2021 第一场游记

Sat, 27 Mar 2021 12:15:00 GMT

爆零

我的 Emacs 配置文件

Fri, 05 Mar 2021 21:53:00 GMT

前面字体设的是 Ubuntu Mono，没有的可以去Ubuntu里拷一份，字体放大了点。剩下的是一些基本的操作，可按需取用。

开启自动全屏、修改C-x、C-f默认位置仅适用于Windows系统。

下面是代码。

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(display-time-mode t)
 '(show-paren-mode t)
 '(tool-bar-mode nil))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(default ((t (:family "Ubuntu Mono" :foundry "outline" :slant normal :weight normal :height 143 :width normal)))))

;; 不显示工具栏
(tool-bar-mode 0)

;; 不显示菜单栏
(menu-bar-mode 0)

;光标改为竖线
(setq-default cursor-type 'bar)

;; 高亮匹配括号。
(show-paren-mode t)
(setq show-paren-style 'parenthesis)

;; 撤销记录扩大。
(setq-default kill-ring-max 65535)

;透明效果
(set-frame-parameter (selected-frame) 'alpha (list 85 50))
(add-to-list 'default-frame-alist (cons 'alpha (list 85 50)))

;一键Eshell
(global-set-key (kbd "C-e") 'eshell)

;设置背景色
(add-to-list 'default-frame-alist '(foreground-color . "#E0DFDB"))
(add-to-list 'default-frame-alist '(background-color . "#000000"))

;取消欢迎屏幕
(setq inhibit-splash-screen t)

;窗口最大化（仅在Windows 中有效）
(run-with-idle-timer 0 nil 'w32-send-sys-command 61488)

;设置标题栏,我的设置为前面显示文档名，后面显示“ - Emacs”
;放久了会还原，选中窗口即可，属正常现象
(setq frame-title-format '("%b - Emacs"))


; 启用时间显示设置，在minibuffer上面的那个杠上
(display-time-mode t)

;显示行号
(global-linum-mode t)

;修改C-x、C-f默认位置 (仅针对Windows)
(global-set-key (kbd "C-x C-f") (lambda () (interactive)
(cd "d:\code")
(call-interactively 'find-file)))

考试的时候可以直接背下面这段：

(tool-bar-mode 0)
(menu-bar-mode 0)
(setq-default cursor-type 'bar)
(show-paren-mode t)
(setq show-paren-style 'parenthesis)
(setq-default kill-ring-max 65535)
(set-frame-parameter (selected-frame) 'alpha (list 85 50))
(add-to-list 'default-frame-alist (cons 'alpha (list 85 50)))
(global-set-key (kbd "C-e") 'eshell)
(add-to-list 'default-frame-alist '(foreground-color . "#E0DFDB"))
(add-to-list 'default-frame-alist '(background-color . "#000000"))
(setq inhibit-splash-screen t)
(setq frame-title-format '("%b - Emacs"))
(display-time-mode t) 
(global-linum-mode t)

附：

Windows 7及以上的系统配置文件放在C:\Users\（当前用户名）\AppData\Roaming\目录下，为一个.emacs文件。

Emacs 刚安装好的时候没有这个文件，又因为Windows 不能生成没有文件名的文件（.emacs的emacs是扩展名），所以可以通过先点Options->Set Default Fonts...->随便更改->Options->Save Options来生成.emacs文件。

Linux直接放主目录下，记得把显示隐藏文件打开。

推广：Windows 上 Emacs 安装指南

【题解】P1283 平板涂色

Fri, 05 Mar 2021 20:31:00 GMT

题目链接：P1283 平板涂色

题面

题目描述

CE 数码公司开发了一种名为自动涂色机（APM）的产品。它能用预定的颜色给一块由不同尺寸且互不覆盖的矩形构成的平板涂色。

为了涂色，APM 需要使用一组刷子。每个刷子涂一种不同的颜色 Ci 。APM 拿起一把有颜色 Ci 的刷子，并给所有颜色为 Ci 且符合下面限制的矩形涂色：

为了避免颜料渗漏使颜色混合，一个矩形只能在所有紧靠它上方的矩形涂色后，才能涂色。例如图中矩形 F 必须在 C 和 D 涂色后才能涂色。注意，每一个矩形必须立刻涂满，不能只涂一部分。

写一个程序求一个使 APM 拿起刷子次数最少的涂色方案。注意，如果一把刷子被拿起超过一次，则每一次都必须记入总数中。

输入格式

第一行为矩形的个数 N。下面有 N 行描述了 N 个矩形。每个矩形有 5 个整数描述，左上角的 y 坐标和 x 坐标，右下角的 y 坐标和 x 坐标，以及预定颜色。

平板的左上角坐标总是 (0,0)。

输出格式

一个整数，表示拿起刷子的最少次数。

输入输出样例

输入 #1

输出 #1

说明/提示

$1\le C_i \le 20$，$0 \le x_i,y_i \le 99$，$1\le N \le 16$。

思路

这题数据范围很小，可以直接搜索。

搜索每一个矩形有没有被涂过，如果没有涂过，

先判断这个矩形能不能涂，用check函数来判断，代码内的注释已经给得非常详细了。

如果能涂的话，再看是不是和刷子颜色一样，如果不是，就++。

代码

#include <iostream>
using namespace std;
int n, ans, x1[20], _y1[20], x2[20], y2[20], color[20];
//y1是关键字，必须在前面加一个下划线
bool visit[20];

void search(int, int, int);
bool check(int);

int main()
{
  cin >> n;
  ans = n; //先把ans设为一个（在本题中）最大的值
  for (int i = 1; i <= n; i++) {
    cin >> _y1[i] >> x1[i] >> y2[i] >> x2[i] >> color[i]; //先输入y坐标，再输入x坐标
  }
  search(0, 0, -1);
  cout << ans << endl;
  return 0;
}

void search(int tot, int finish, int col)
{
  if (tot >= ans)
    return; // 如果总数已经大于ans的值了，就可以不用继续了
  if (finish == n)
    ans = tot; //如果已经搜索完毕了，就直接把tot的值赋给ans
  for (int i = 1; i <= n; i++)
    if (!visit[i] && check(i)) {
      visit[i] = true;
      if (color[i] == col) { //如果找到了是这个矩形那就给它涂色
        search(tot, finish + 1, color[i]);
      }
      else { //如果找到的矩形颜色不一样，就finish++，继续涂色
        search(tot + 1, finish + 1, color[i]);
      }
      visit[i] = false; //回溯
    }
}
bool check(int k)
{
  for (int i = 1; i <= n; i++)
    if (!visit[i]         //如果循环到的矩形没涂过色
       && _y1[i] == y2[k] //判断要涂色的矩形是否下好在循环到的矩形下方
                          //可通过判断循环到的矩形的下面那条边的纵坐标是否与
                          //要涂色的矩形上面那条边的纵坐标相等
       && ((x1[i] >= x1[k] && x1[i] <= x2[k])   //循环到的矩形的左边界在要涂色的矩形左右边界之间
        || (x2[i] >= x1[k] && x2[i] <= x2[k]))) //循环到的矩形的右边界在要涂色的矩形左右边界之间
      return false;
  return true;
}

Windows 上 Emacs 安装指南

Mon, 08 Feb 2021 22:14:00 GMT

啊，最近又有人问我在Windows 上Emacs怎么安装。

嗯。Windows 上安装Emacs的确没Linux方便。

下面切入正题。

首先，打开GNU Emacs官网。这次官网没炸。

点击Windows

点击Windows后能打开如下界面：

点击nearby GNU mirror：

当然，你也可以点击main GNU FTP server。（补：我现在发现main GNU FTP server挺快的）

有的时候推荐的最近的镜像站打不开，就像这样

遇到这种情况只需要返回并重新进入即可。一次不行就多试几次

点开来之后见到这样的界面：

选择最新版本的进入，我这个时候最新版本是27。点开来就像这样：

这里有32位和64位两个版本。简单介绍一下如何判断自己的电脑是32位还是64位。

演示系统为Windows 10 20H2

在设备规格一栏中能见到以下一项：

我的是64位操作系统。

比我的系统版本低的应该能看到这样的：

（一看就是虚拟机）

这样我们就区分开来了32位和64位的操作系统。

（上面的框框错了，上边界应该往下两行）

上图中上面的框指的是32位的，下面的框是64位的。以64位的为例：

上面这两个选项中两个的区别不太好说，我用下面这个。

下载下来像这样

选我下面给的这个选项解压，点别的话会导致解压的文件夹文件很多。

建议放在C:\Program Files文件夹下

有可能会报错，如果你的是管理员账户的话就直接点继续，不是的话就只好放别的地方了。

然后打开文件夹里面的bin目录，打开addpm.exe

弹出如下窗口（背后有一黑的控制台），点击确定。

然后你就能在开始菜单里发现这个：

要添加桌面快捷方式的话，右键点击固定在开始屏幕

然后到开始屏幕拖动它，按住鼠标点Ctrl + D到桌面，松开鼠标创建桌面快捷方式。

然后就可以享受你的Emacs了。

附：Windows 7及以上Emacs配置文件目录：C:\Users\（当前用户名）\AppData\Roaming

Windows不能直接建立.emacs文件，需要通过在Emacs里先保存配置文件再修改。下次详细说明。

我的 Emacs 配置文件

C++ 快读快写模板

Mon, 08 Feb 2021 08:34:00 GMT

UpDate 2021/7/19:

感谢 @Eason_AC 的指点，快读、快写将可以支持任意整型变量的输入与输出。

正文

由于快读和快写需要用到 <cstdio> 头文件中的 getchar() 和 putchar() 函数，所以在代码的开头请加入如下代码：

#include <cstdio>

函数支持变量类型多样，请在调用 read() 函数时在 read 与 () 之间加入 <您要读入的变量类型>。例：int a = read<int>();。

快读：

template<typename T> inline T read() {
  T X = 0; bool flag = 1; char ch = getchar();
  while (ch < '0' || ch > '9') {if (ch == '-') flag = 0; ch = getchar();}
  while (ch >= '0' && ch <= '9') {X = (X << 1) + (X << 3) + ch - '0'; ch = getchar();}
  if (flag) return X;
  return ~ (X - 1);
}

快写：

template<typename T> inline void write(T X) {
  if (X < 0) {putchar('-'); X = ~ (X - 1);}
  int s[50], top = 0;
  while (X) {s[++top] = X % 10; X /= 10;}
  if (!top) s[++top] = 0;
  while (top) putchar(s[top--] + '0');
  putchar('\n');//根据情况自行修改
  return;
}

一键复制快读快写：

template<typename T> inline T read() {
  T X = 0; bool flag = 1; char ch = getchar();
  while (ch < '0' || ch > '9') {if (ch == '-') flag = 0; ch = getchar();}
  while (ch >= '0' && ch <= '9') {X = (X << 1) + (X << 3) + ch - '0'; ch = getchar();}
  if (flag) return X;
  return ~ (X - 1);
}

template<typename T> inline void write(T X) {
  if (X < 0) {putchar('-'); X = ~ (X - 1);}
  int s[50], top = 0;
  while (X) {s[++top] = X % 10; X /= 10;}
  if (!top) s[++top] = 0;
  while (top) putchar(s[top--] + '0');
  putchar('\n');
  return;
}

例题

A + B Problem

#include <cstdio>

template<typename T> inline T read() {
  T X = 0; bool flag = 1; char ch = getchar();
  while (ch < '0' || ch > '9') {if (ch == '-') flag = 0; ch = getchar();}
  while (ch >= '0' && ch <= '9') {X = (X << 1) + (X << 3) + ch - '0'; ch = getchar();}
  if (flag) return X;
  return ~ (X - 1);
}

template<typename T> inline void write(T X) {
  if (X < 0) {putchar('-'); X = ~ (X - 1);}
  int s[50], top = 0;
  while (X) {s[++top] = X % 10; X /= 10;}
  if (!top) s[++top] = 0;
  while (top) putchar(s[top--] + '0');
  putchar('\n');
  return;
}

int main() {
    int a, b;
    a = read<int>(), b = read<int>();
    write(a + b);
    return 0;
}

Windows 上 G++ 安装指南（演示系统：Windows 10）

Sun, 07 Feb 2021 14:15:00 GMT

Update 2025/12/3 现在我自己都不用这个方法了，我都直接下一个带MinGW的Code::Blocks然后直接把他的g++设置到环境变量里

Update 2021/8/6 文件换到蓝奏云上了，下载体验应该会让人更舒适一些

Update 2021/2/8 有同学测试貌似下载不了了，目前正在观察

有很多同学都不知道如何安装G++编译器，直接使用Dev-C++的编译器。

直接使用Dev-C++的G++编译器在64位操作系统上没问题，在32位操作系统上就会出问题。

现在本文介绍一下安装原版G++的方法。

打开MinGW官网，

？？？

慢着，MinGW官网好像污染了

经验证，要用某些操作才可以正常访问。

验证日期：2021/2/7 时间：下午2：15

啊，应该没事，直接提供网盘链接：

https://wws.lanzoui.com/ih3Bksaipmd 密码：gcpp

原百度网盘链接：https://pan.baidu.com/s/1fNR67KrLRmO-v4s9TRNTQw 提取码：yhsq

其他下载链接：https://share.weiyun.com/KrwHH9ud；https://url20.ctfile.com/f/33117920-505073190-a1f4fd 密码：2792

打开后，一路戳Install那个位置就行了。

安装好后，会自动开启，没有自动开启的点这个：

点开界面之后，应该能看到类似这样的界面：

我这里因为安装好了，所以那个mingw32-gcc-g++-bin前面有绿的标记。

没有安装好的应该和别的一样。

然后右键，点击Mark for Installation。

因为已经装好了，我这里就点不了了。

然后这项前面就应该有一个标记。

再点击菜单栏的Installation，再点击Apply Changes。

照样，我已经装好了，所以点不到。

然后再点击Apply，就不提供截屏了。

然后就是等待下载。下载很慢，有时会发生错误。发生错误有Apply就点，没有就随便点。

下载完成后，在C盘根目录下应该有MinGW文件夹，

看到了那大概率是安装成功了。

接下来我们添加环境变量。

我用的是Windows 10，Windows 7的不太一样，你们百度一下就知道怎么做了。

首先打开设置，点击“系统”：

在左边最下方找到关于，再在右边点击高级系统设置

点开来就像下面这样：

点击环境变量：

点开后在下面的系统变量中找到Path，点编辑：

点击“新建”，输入“C:\MinGW\bin",点确定。

然后把前面的窗口关掉，重启你的编译软件，再试试，应该就可以正常用G++编译了。

淼畔

解决 MCSM 面板不能直接使用 run 启动 run.bat 作为启动命令的问题

禁用 Firefox 全屏提示和动画

把 GitHub 网站上显示的提交消息全部替换成“修复了一些已知问题”

安装方法

效果演示

安装前

安装后

仓库地址

免责声明

当你发现 TRAE 对 Java 环境变量改变无动于衷

闲得没事还是别折腾 Astro 了

AI Studio GPU 占用过高导致卡顿的解决办法

Firefox 禁用按下 Alt 显示菜单

题解：Kuangyeye's Random Number

Problem Description

Input

Output

Sample Input

Sample Output

Note

Solution

Windows 的一些设置

使用 S3 睡眠模式

开机默认启用 NumLock

开启和关闭临时 IPv6 地址

禁止鼠标唤醒

薄荷输入法配置

启用微软双拼

更改候选词个数、最大输入长度

候选词水平排列

安装万象拼音模型

关闭一些快捷键

关闭双拼编码转义

输入首字母被吞等奇怪问题

导入词库

小白被 Linux 玩随便记录点东西

关闭动画

第一步：关闭 KDE 桌面本身的动画（窗口、菜单等）

第二步：强制第三方应用（QQ、浏览器等）关闭动画

第三步：验证与后续

补充：如果某些应用依然有平滑滚动

禁用 USB 鼠标唤醒

找到鼠标的 ID

创建 Udev 规则

生效与测试

特殊情况说明

Shebang

详细解释

ssh 卡死

睡眠模式改为 deep

临时切换

永久切换

开机自动打开 NumLock

开机自动登录时提示 Unlock Login Keyring

解决方法

第一步：安装管理工具

第二步：修改密钥环密码为空

第三步：重启电脑

双系统隐藏 grub

把登录界面改回 SDDM

NVIDIA GPU 突破 55W 功耗墙

关闭临时 IPv6 地址

关闭独显

NVIDIA GPU 周期性卡顿

利用 scp 传输文件

微软大战代码 怎么不能鼠标中键选择矩形区域

方法一：修改 VS Code 设置（最推荐）

方法二：使用键盘+左键组合（通用替代方案）（未经验证）

方法三：切换“列选择模式”

总结

华硕笔记本的一些其他东西

准备工作

第一步：安装 supergfxctl (显卡切换工具)

第二步：安装 asusctl (整机控制工具)

第三步：安装图形界面 (可选但推荐)

第四步：重启与验证

常见问题解决

自动挂载非系统分区

方法一：使用 KDE 系统设置 (最简单，无需修改系统文件)

睡眠模式改为 `deep`

开机自动登录时提示 `Unlock Login Keyring`

微软大战代码怎么不能鼠标中键选择矩形区域