rqdmap | blog

在 OBS 中通过采集卡调试无显示器主机

Thu, 29 Jan 2026 21:28:24 +0800

没错, OBS 中也可以使用 Linux 系统! 但这不是什么类似于在 PDF 中执行 Linux 的高端玩意, 只是因为手头有一台捡垃圾拼来的台式机, 但没有适配 VGA 接口的显示屏幕, 唯一正在使用的带鱼屏也因为屏幕自身问题无法支持默认分辨率与刷新率输出..

探索后发现可以通过采集卡的方式将 VGA 信号走 USB 接口输出到 OBS 中作为信号源, 这样就可以借助另外的一块笔记本屏幕查看视频信号了

2025软考高级架构师-考试总结

Tue, 16 Dec 2025 16:52:17 +0800

本文回顾了 2025 年秋季软考高级架构师的备考与考试经历. 文章分享了通过 Anki 快速刷客观题的经验, 探讨了案例分析和论文的准备策略, 并反思了因论文准备不足导致的失利. 此外还分享了考试当天的体验, 记录了在备考过程中对 PDF 标注、本地知识库管理等工具的探索, 以及对明年继续冲刺的展望.

Magisk 隐藏应用残留清理方法

Thu, 03 Jul 2025 15:25:38 +0800

OTA 升级后, 使用随机包名隐藏的 Magisk 应用可能因权限丢失而无法正常卸载, 同时阻止新 Magisk 正确识别 Root 状态. 本文介绍通过 ADB 命令定位和清除此类残留应用的方法.

京城碎笔

Sun, 01 Jun 2025 20:57:52 +0800

人对时间的感受确实是对数的. 回首望去, 仿佛还没有干些什么了不起的事情, 就在不经意间的一日三餐、日升日落之间度过了在北京的三年. 但细细数来, 又好像多少还是做了一些事情, 只是总感觉是很瞬间的事情, 既感受不到时间跨度的存在, 也难以回忆起当时丰富的心境. 事情只是一件一件发生, 情感也只是此起彼伏地变化着. 每当想要记录一些什么时, 又像是费尽心思探赜索隐一样, 努力回忆彼时彼刻的心情, 也是一件劳苦事情. 只是在北京上学的这三年, 也恍惚间就结束了, 这期间还是经历到了很多不同事情、学习到了一些好玩的技术, 不写点什么总感觉就会稀里糊涂忘记, 因此还是努力记录一些什么.

SSH 隧道管理与安全加固

Thu, 10 Apr 2025 19:37:52 +0800

本文详细描述了基于 SSH 隧道的端口转发解决方案, 替代了原有的 frp 方案. 通过 systemd 模板单元和辅助脚本, 实现了动态 IP 与静态 IP 并存的管理方式, 并将隧道配置与具体的执行过程解耦. 文章提供了 SSH 反向隧道的配置示例, 并探讨了安全加固措施, 包括 iptables 限流和 sshd 配置调整, 以应对公网上的暴力破解尝试.

QEMU 中实现基于 UEFI Secure Boot 与 TPM 的 GRUB 可信引导

Tue, 18 Mar 2025 21:53:19 +0800

可信启动通过 TPM 的完整性度量机制扩展 UEFI 安全启动的签名验证能力，形成从硬件信任根到操作系统的完整信任链. 本文将探讨如何在 QEMU 虚拟环境中实现基于 UEFI Secure Boot 与 TPM 的 GRUB 可信引导过程, 包括原理解析、环境搭建、配置方法及验证测试, 为读者提供一个可复现的技术实践指南, 帮助深入理解可信计算的基础机制.

从 Alacritty 到 Wezterm: 解决旗帜 Emoji 渲染问题

Wed, 05 Mar 2025 16:59:29 +0800

本文针对 Linux 环境下终端 Emoji 符号渲染异常问题(如区域指示符无法正确显示为区域的旗帜), 从字体配置与终端工具两个角度展开分析. 通过排查 Alacritty 的字体回退机制、尝试合并多字体方案, 最终定位到 Unicode 版本兼容性问题, 通过切换至 Wezterm 终端并配置 Unicode 版本正确渲染国旗 Emoji. 文中记录了在尝试过程中的字体选择(Iosevka、思源黑体、Sarasa 更纱黑)、终端对比(Alacritty 与 Wezterm)及配置实现过程, 为无桌面环境下的 Linux 字体管理提供实践参考.

Draw.io 自动化中英文字体混排方案

Tue, 25 Feb 2025 19:17:18 +0800

update: 经 xueaohui 分享, 原生 Draw.io 可以支持中英文混排, 将每个字体用单引号分隔, 字体间用逗号连接即可, 例如: 'Times New Roman','Simsun'

ELF 文件结构与分析

Tue, 18 Feb 2025 17:22:52 +0800

本文主要整理与学习了 ELF 文件的基本格式, 使用 readelf, gdb, objdump 等工具实际分析了 ELF 部分节区的字段细节, 但受于篇幅限制, 未对与 ELF 关联甚深的程序动静态链接、加载过程进行深入分析, 因此本文仅作为 ELF 基本结构的一个基本介绍与入门.

Neovim 打造 Java8 开发环境

Fri, 19 Jul 2024 22:54:21 +0800

这是一篇一看标题就很邪教的文章, 尽管拥有了 LSP 加持的 Neovim 处理大部分其他主流语言的项目都是游刃有余, 可是很难想象会有人愿意在 Java EE 开发(国内可以认为等价于 Spring 生态)中使用它, 尤其是项目本身极有可能具有沉重历史包袱而不得不使用的古老的 Java8..

本文将说明我在基于 Neovim 开发 Spring 项目时的一些粗浅尝试与配置技巧.

nvim-cmp 支持前缀匹配优先的补全

Fri, 19 Apr 2024 20:53:39 +0800

在我的 Neovim 配置中, 一直使用的是 nvim-cmp 作为补全引擎, 由于其默认支持模糊查找, 因而补全列表中可能会出现前缀匹配优先级不如子序列的乱序问题, 举一个例子:

补全候选项中有 abc_variable 和 xaxbx 这两个词
输入 ab, nvim-cmp 根据传入的比较函数进行逐个比较与排序; 但由于默认支持模糊查找, 且官方的补全函数中貌似没有前缀匹配优先的规定, 而我自己很合理地又添加了一个根据长度排序的比较函数, 因而在补全列表中, 子序列 xaxbx 反而会获得更高的优先级出现在第一个, 这是极为不合理的.

2023 年度总结

Thu, 04 Jan 2024 23:58:04 +0800

尽管 2023 年不太特殊, 甚至容易发现不是素数(7*17*17), 不过对我个人而言 2023 是经历了许多、学习了许多的一年, 因此考虑做一个年度的自省与总结, 以期留下一些结构化的记忆以供后来者翻阅.

Python 进阶技巧: 类与继承

Thu, 04 Jan 2024 23:16:51 +0800

本文主要介绍有关 Python 中类(class)与继承(inheritance)的一些高级使用知识与技巧, 包括:

与类相关的若干内置函数
多继承下的 MRO 序列与 C3 序列化方法
super 类的使用
魔术方法与类的实例化过程

实用Linux桌面系统定制化方案

Sun, 03 Dec 2023 21:42:56 +0800

前前后后折腾自己使用的这套Linux桌面系统也有一年多的时间了, 但是由于其中涉及的事务纷繁细琐, 因而一直没有专门整理过一篇内容对其做系统的介绍. 不过由于这个周末又重构了之前的一套账单处理工具和一些常用脚本, 一下子便感觉到目前系统和功能服务已经愈发复杂起来了, 可以考虑对其做一个简单的介绍以便更好的传教(不是)

Android微信记录备份方案

Mon, 20 Nov 2023 00:44:03 +0800

在还没有解锁root时, 我偶尔便会闲来无事查查看微信的用户记录导出方案, 一些方案是基于Windows的聊天记录解密, 如: windows取证之导出微信&QQ聊天记录, 还有一些是基于IOS系统的Itunes来做导出. 总的来说都不是很满足需求, 基于Windows的方案一来看评论说只能解密当前的缓存数据, 除非每几天登陆一次电脑微信不然数据就不完整, 另外常用的设备也不会是windows而是安卓, 而Itunes的更不说了, 我也没有一台适合当作中转站的IPhone系列.

Pixel7 Root 解锁与折腾小记

Wed, 15 Nov 2023 23:36:02 +0800

本文将说明 Pixel Root 解锁与OTA的恢复方式, 并记录一番在折腾过程中踩过的坑, 以供后续查阅.

TL; DR 如何恢复Root?

通常情况下, Pixel 自动推送的更新总是会覆盖掉 Root, 这边将简洁地给出如何恢复 Root 的过程以供查阅, 全部操作过程应当不超过15分钟.

因为是恢复root, 因而这里将不介绍adb工具套件的获取、bootloader的解锁等过程

Mac(x86派)的废物再利用

Sat, 09 Sep 2023 19:48:33 +0800

手头有一个退下来的mbp, 是老版本因而搭载的还是x86的CPU, 同时由于电源被我通过拓展坞充了次电而弄坏过, 因而一旦断电会光速关机.. 加上mbp真的是用到后面(大概4年)越用越卡, 让人怀疑macos是不是搞了什么鬼或怎么样.. 总之这台机子不太能当作主力机了, 退下来后也没怎么用过, 装了个windows但是用起来也是卡卡的, 前阵子拿来实验室企图当个服务器用, ntr上了个archlinux后但是也不知道拿来做什么, 正巧最近发现主力机的ssd/文件系统可能有问题, 因而考虑拿mbp来当一个x86派使用, 做做备份或者其他一些什么事情.

Rust项目结构与测试

Wed, 06 Sep 2023 16:05:50 +0800

由于 rqdmap/rust-in-competitive-programming项目冉冉升起, 希望对代码更加有条理地进行维护和组织, 因而学习一下cargo中有关项目, 包, 模块, 以及测试的一些内容, 做一个简单够用的知识学习与整理.

~~实际上是项目代码写了不少了, 整体结构也划分好了, 再来补了完善了这篇博客; 因为大概喜欢写测试的技术人员不多吧:/~~

不安全Rust: unsafe编程

Tue, 22 Aug 2023 21:01:26 +0800

在 rCore-OS: 批处理系统 - rqdmap | blog初次见到了unsafe的相关代码, 当时并未系统学习, 只是草草了解, 这里补上相关的内容知识. Rust编译器提供了强大的编译期安全保障, 不过其仍然为我们提供了unsafe关键字, 供我们写一些 “不安全的” Rust黑魔法.

unsafe简介

为什么会有unsafe的需求?

Rust中的智能指针

Tue, 01 Aug 2023 16:56:40 +0800

通常说来, 指针是一个包含了内存地址的变量, 而内存地址引用/指向了另外的数据.

在Rust中, 最常见的指针类型是引用, 其借用其他的变量的值, 除了指向某个值以外就没有其他的功能了. 没有性能损耗, 是Rust中使用最多的指针.

Rust中的智能指针则相比于一般指针更加复杂, 其中包含诸如长度、容量、元信息等额外信息. 相比于引用会借用数据, 智能指针还能拥有其指向的数据, 然后再向他人提供服务. String和Vec都是常见的智能指针.

rCore-OS: 批处理系统

Wed, 26 Jul 2023 19:29:04 +0800

系列文章

rCore操作系统实践 - rqdmap | blog

本章主要目的为设计和实现支持批处理操作的OS, 其相比于上一节的库OS而言, 主要的不同在于:

OS自身运行在内核态; 支持其他应用运行在用户态并发出系统调用
一个接一个的运行不同的应用程序

为了实现这些目的, 本章节需要做的事情分为:

调整应用程序, 使其能够发出系统调用; 操作系统提供额外的功能支持应用程序的执行, 包括但不限于sys_write, sys_exit等具体的系统调用功能.

rCore-OS: 基本执行环境

Mon, 24 Jul 2023 19:30:54 +0800

系列文章

rCore操作系统实践 - rqdmap | blog

本章主要是讲解如何设计和实现建立在裸机上的执行环境, 并让应用程序能够在这样的执行环境中运行.

导言中说:

大多数程序员的第一行代码都从 Hello, world! 开始，当我们满怀着好奇心在编辑器内键入仅仅数个字节，再经过几行命令编译（靠的是编译器）、运行（靠的是操作系统），终于在黑洞洞的终端窗口中看到期望中的结果的时候，一扇通往编程世界的大门已经打开。

rCore操作系统实践

Sun, 23 Jul 2023 20:38:23 +0800

系列文章

rCore-OS: 基本执行环境 - rqdmap | blog rCore-OS: 批处理系统 - rqdmap | blog

在寻找Rust实践性的学习材料的过程中发现了 rCore-OS项目, 其基于RISC-V架构实现一个用Rust写的操作系统; 教程看上去也不错, 十分的详实且成体系: rCore-Tutorial-Book-v3 3.6.0-alpha.1 文档

因而准备照着教程学习一下rcore-os, 并企图在过程中对Rust的基本编程与操作系统等方面都能获得更进一步的理解.

网页字体精简方案

Fri, 21 Jul 2023 02:13:05 +0800

这是一个令人兴奋的想法! 其目的在于按需精简字体库, 以使得网页在保证显示效果的同时减少需要传输的数据量.

我个人使用的字体为思源黑的CJK+Iosevka的西文, 为了实现强制爱(x), 之前对于博客字体的处理方式都是用css指定本地的字体文件, 手动压一份woff2的Iosevka和思源黑的字体放在网站服务器上, 如果用户没有的话就去下载吧(导致加载缓慢), 而且由于缺省字体的存在, 会造成特别明显的FOUT(Flash Of Unstyled Text)问题, 特别是最近新加坡接连抽风, 不确定是不是被FireWall管控了, 流量被控制了, 经常出现字体根本下载不出来的情况.

SUID与程序执行

Fri, 14 Jul 2023 15:08:34 +0800

在之前的博客 ArchLinux调优: 显卡、声卡与电源 - rqdmap | blog中说明了如何使用开源的nvidia驱动并且关闭nvidia的供电来使得笔记本续航能力的提升.

通常来说我们不希望每次开机后都要手动向bbswitch写off字符串, 因而一般委以重任给dm; 不过像ly这样的纯终端dm貌似不具备在X Server加载后、登陆进入系统前的这个时间段执行一些脚本(可能因为ly运行在X Server加载前!), 因而后来出于种种考虑使用的是lightdm加载器, 比较现代, theme支持前端技术, 也比较好看, 最重要的是图形化的启动界面意味着可以在X加载后执行一些脚本.

软件所实习体会与总结

Fri, 07 Jul 2023 22:24:10 +0800

眨眼间就在软件所搞了4个月不到点的科研实习, 今天汇报完最后一个项目, 彻底run了, 浅浅记录一些心得体会..

实习本身任务不算重, 线上实习, 无严格的考勤, 每周3-4天, 期间总共做了三个研究项目:

Kernel Mode Linux:
Sched_ext 拓展调度技术
- sched_ext机制研究
编译期间内核优化技术

真要说起来, 三个项目可能写了有几千行LaTeX代码, 而编程语言则是一行没写(sh和python脚本语言可能倒是写了点!)..

有关博客与笔记的思考

Fri, 07 Jul 2023 11:09:29 +0800

这是一些有关于博客内容的思考, 事实上在之前就有过一些想法, 曾经在about的Todo列表中写过:

增添弃坑等标签, 允许保留与查看这些博客, 但不在主页渲染

当时就意识到了目前百余篇博客中可能一大部分都是一些思想的碎屑, 或者是一些草稿纸上的笔记, 真正让人满意的、好的技术博客可能寥寥.

翻看到这样一篇帖子也是进一步唤起了一些有关后续博客内容的思考:

Bluespec与CPU(MIT6.375)

Sun, 25 Jun 2023 20:43:50 +0800

BUAA 6系高等机组实验作业, 使用bluespec工具链编程, 实现一个{,非}流水的右移器以及一个精简MIPS指令集CPU的一微小的部分.

课程疑似参考 6.375 Complex Digital Systems - Spring 2006; 因为 PPT的风格是一模一样的, 但是课程年份与内容应该可能有所出入, 不进行一个几乎是20年前课程的考据了.

环境搭建

实验默认提供的环境是ssh + X11转发, 不过在我的机器好像有问题:

Linux内核中的Rust使用

Mon, 05 Jun 2023 16:09:12 +0800

内核代码选用Linux-6.3.4, 对其中有关Rust代码进行简单的分析.

ArchLinux: 蓝牙支持

Thu, 25 May 2023 02:09:43 +0800

前言

在考虑购买 HHKB 时, 由于有线版本只要1k, 带有蓝牙的双模则要2k5.. 不过由于蓝牙无线确实是十分的方便, 因而还是希望测试一下本机的蓝牙模块.

操作教程

主要参考 <Bluetooth - ArchWiki>即可.

ArchWiki 中的相关内容

本机是Dell G5520 Nvidia, 可以修改ArchWiki对应的部分了:)

Bluetooth - ArchWiki

安装几个相关的包:

NixOS: 选择与放弃

Wed, 24 May 2023 17:50:09 +0800

偶然听说了NixOS, 其万物皆配置文件的理念深深地吸引了我. 由于Arch下的pacman对于系统的监控总是不够地完全, 完全可能出现安装的某个包被卸载后一些配置/数据文件遗留在本机(经过测试, pacman -Rsun并不行, 后续考虑结合pacman -Ql写一些钩子函数), 或者是我修改了若干位于/etc/目录下的文件但这些修改并不会被包管理器追踪, 这极大地造成了系统状态的不确定性(冗余垃圾+不可复现). 因此, NixOS的理念从一开始就极大地吸引了有一些系统洁癖的我.

Neovim插件管理与配置

Mon, 24 Apr 2023 16:40:28 +0800

为Nvim添加了nvim-cmp插件栈… 之前一直没有动手, 只单独安装了几个无复杂依赖的插件, 这次直接一口气从nvim-cmp补全插件, LSP相关, 代码块补全, 模糊查找等全部搞好了..

其实际上高度耦合… 代码块补全以及LSP最终必须全部集成到nvim-cmp中, 而且还更新了代码块补全为luasnip这个lua编写的补全前端(?不确定), 丢弃了原本的utlisnip, 因而还把所有自定义的代码块全部用luasnip的语法重写了..同时, 修改了插件管理器为lazy.nvim, 重构了我的nvim的所有配置文件的目录树结构..

ArchLinux调优: 显卡、声卡与电源

Sun, 23 Apr 2023 01:29:36 +0800

记录一些最近针对本机硬件设备驱动相关的调整与优化(?反向优化), 主要涉及到Nvidia独立显卡, Intel声卡以及电源管理等几个部分.

电源管理

在使用Windows时基本上是稳定1.5-2h左右, 去年刚配置好我的bspwm桌面系统后却能使用到4h… 结果目前Linux的续航又变成2h了.. 所以研究一下如何对Linux的电源进行监视与管理.

sched_ext机制研究

Sun, 09 Apr 2023 19:41:48 +0800

Slide

充斥着大量的谬误与个人的随意理解: sched_ext机制研究

简介

BPF背后的核心思想是, 它允许程序在运行时从用户空间加载到内核中; 与现在的Linux系统相比, 使用BPF进行调度有可能实现明显不同的调度行为. 那么, 为什么现在要提出BPF机制呢? 为了期待一场长时间的讨论, 补丁系列的封面信详细描述了这项工作背后的动机. 简而言之, 该论点认为, 在BPF中编写调度策略的能力大大降低了试验新调度方法的难度. 由于引入了完全公平调度器CFS, 我们的工作负载及其运行的系统都变得更加复杂. 要开发适合当前系统的调度算法, 需要进行试验. BPF调度类允许以一种安全的方式进行实验, 甚至不需要重新启动测试机器. bpf编写的调度器还可以提高可能不值得在主线内核中支持的小众工作负载的性能, 这些工作负载更容易部署到大量系统中.

Logisim开发单周期MIPS处理器

Thu, 06 Apr 2023 18:20:09 +0800

作为计组第一次实验的报告模板进行整理, 内容为使用Logisim开发单周期MIPS处理器, 支持的指令集仅有: addu, subu, ori, lw, wsw, beq, lui这7条, 其中addu以及subu不必要实现溢出.

实验环境

<Logisim-Ita/Logisim: Logisim Italian Fork>

对Linux的支持还算可以, 因而直接在Linux上进行实验即可.

总体设计

下图展示了该单周期处理器的总体设计:

Linux下修改文件的4个时间

Fri, 24 Mar 2023 13:43:36 +0800

由于一些原因… 接触到了如何修改Linux(/windows)下文件4个时间的方式.

修改时间

修改Access time 与 Modify time:

bash

1touch -a <file> -d '2000-01-01 08:15:23'
2touch -m <file> -d '2000-01-01 08:15:23'

而Change time与Birth time貌似是与fs相绑定的, 比如在Linux的ext4下打包一个zip, 传送至windows的ntfs中解压, 显示的创建时间也只是当时windows的时钟所显示的时间… 关于这一点尚未仔细研究, 不过由于修改这两个时间的方式一般都是通过修改系统时钟.

clash+systemd自启动问题

Fri, 24 Mar 2023 13:43:18 +0800

通常来说, 参考网上最常见的guide来配置systemd + clash 没有问题: <Running Clash as a service · Dreamacro/clash Wiki>

bash

 1[Unit]
 2Description=Clash daemon, A rule-based proxy in Go.
 3After=network.target
 4
 5[Service]
 6Type=simple
 7Restart=always
 8ExecStart=/usr/local/bin/clash -d /etc/clash
 9
10[Install]
11WantedBy=multi-user.target

问题排查

但是在我的配置中(优先走的是url-test策略组)会出现一些问题:

KML: 实现机制研究

Thu, 16 Mar 2023 21:11:00 +0800

本文将参考作者给出的guide, 深入研究IA-32下KML机制的工作原理以及相关技术.

有关于KML技术的使用可以参考: <启用Kernel Model Linux - rqdmap | blog>

工作原理

To execute user programs in kernel mode, Kernel Mode Linux has a special start_thread (start_kernel_thread) routine, which is called in processing execve(2) and sets registers of a user process to specified initial values. The original start_thread routine sets CS segment register to __USER_CS. The start_kernel_thread routine sets the CS register to __KERNEL_CS. Thus, a user program is started as a user process executed in kernel mode.

文件arch/x86/kernel/process_32.c中涉及两处KML的补丁:

duu: 按照大小排序的du指令

Mon, 13 Mar 2023 12:12:45 +0800

正确的办法!

du -d 1 -h | sort -hr

duu

du 指令无法以可读的形式按照大小排序, du -d 1 -h | sort -nr并不正确, 因而写一个简单的脚本进行实现.

rust

 1use std::env; 
 2
 3fn main() {
  let args: Vec<String> = env::args().collect();
  assert!(args.len() >= 2);
 6
  if args[1].len() > 18 {
      println!("Number too large");
      return;
  }
11
  for c in args[1].chars() {
      if !c.is_digit(10) {
          println!("Invalid number");
          return;
      }
  }
18
  let nr_bytes = args[1].parse::<u64>().unwrap();
  /* KB -> MB -> GB */
21
  let mut level: usize = 0;
  let mut tmp = nr_bytes;
  while tmp > 0 {
      tmp /= 1024;
      if tmp > 0 {
          level += 1;
      }
  }
30
  // du指令默认的单位是KB!
  let levels = ["KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
  print!("{:>.2}\t{}\t", nr_bytes as f64 / u64::pow(1024, level as u32) as f64, levels[level]);
34}

再用awk处理一下du的第一列输出.

Acme.sh+ZeroSSL证书部署

Fri, 10 Mar 2023 13:20:21 +0800

之前一直沿用的最老的服务器的ssl证书提供商 FreeSSL首页 - FreeSSL.cn一个提供免费HTTPS证书申请的网站, 前阵子发现不知道怎么不太行了, 偶尔会出现证书不被信任的情况, 过一段时间可能会自己恢复… 不过去官网查了下发现自己的账号下居然好像又没有这份证书… 很奇怪, 总之打算换一下SSL证书提供商.

KML: 启用Kernel Model Linux

Wed, 08 Mar 2023 10:58:52 +0800

KML简介

Kernel Mode Linux: Execute user processes in kernel mode 是一种允许用户程序运行于内核态的技术. 处于内核态的程序可以直接访问任意的内核空间, 无需再使用软中断和上下文切换等手段进行系统调用. 此外, 这些程序也会正常的参与分页和调度, 这样哪怕这些程序死循环, 整个系统也不会因此卡死.

如何使用KML? 编译了打好补丁的内核后, 在/trusted/目录下的程序将自动进入内核态运行.

基于QEMU搭建内核调试环境

Mon, 06 Mar 2023 14:58:27 +0800

搞一份内核源码, 并尝试调试一个拓展内核功能的补丁 Kernel-Mode-Linux; 对于该模块的调试与分析见后续博文< 启用Kernel Model Linux>

Linux内核编译

这里使用的是Linux4.4.12(4.0.*, 3.1*, 2.6.*系列也有尝试过), 并且还需要打上PREEMPT_RT实时内核补丁, 借鉴于Github KML仓库:

bash

 1# 0. Clone this repository
 2git clone git@github.com:sonicyang/KML.git
 3
 4# 1. Clone Linux 4.4.12
 5git clone -b v4.4.12 --depth 1 git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
 6
 7# You will get a copy of Linux 4.4.12 source in directory linux
 8
 9# 2. Download PREEMPT_RT patch
10wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/4.4/older/patch-4.4.12-rt18.patch.xz
11
12# You will get a file patch-4.4.12-rt18.patch.xz
13
14# 3. Apply the PREEMPT_RT patch
15cd linux
16xzcat ../patch-4.4.12-rt18.patch.xz | patch -p1
17
18# You will have a modified Linux 4.4.12 source with PREEMPT_RT, now.
19
20# 4. Commit the the changes at once (Otherwise, git am will fail)
21git add .
22git commit -m "Apply PREEMPT_RT"
23
24# Now you should have a clean git repository without unstaged changes
25
26# 5. Apply these 2 patches
27cp ../KML/*.patch .
28git am *.patch
29
30# You are good to go
31# Compile the kernel then you should be able to use KML

PREEMPT_RT补丁

关于该内核补丁, 是为了将Linux内核拓展为一个实时的操作系统.

Rust-泛型与特征

Wed, 22 Feb 2023 15:31:34 +0800

Rust的泛型(Generics)和特征(Trait)看的一个头两个大… 需要仔细学习整理一下, rust_course的标题分类感觉有点confusing…

泛型

如何使用泛型?

泛型函数:

rust

1fn largest<T>(list: &[T]) -> T{
2	..
3}

泛型结构体:

rust

1struct Point<T> {
2    x: T,
3    y: T,
4}
5
6fn main() {
7    let integer = Point { x: 5, y: 10 };
8    let float = Point { x: 1.0, y: 4.0 };
9}

泛型枚举:

双系统环境下重装 Windows10

Sat, 18 Feb 2023 23:26:27 +0800

因为 Win11 开机后经常会在使用 Chrome 等应用时卡死的问题并未得到修复, 最终在某一天 Windows 的崩溃问题终于扩散到了同一块磁盘上的 Linux 分区: 在一次 Windows 卡死并蓝屏后, 自动运行的 Dell 自动修复清空了我的 EFI 分区, 导致我的 Linux 系统也无法正确引导了.. 当时我仍然以为是 Windows 系统的问题, 因此尝试在维持 Linux 分区数据的同时, 重装 Win10 系统.

ArchLinux上安装zathura-develop

Mon, 13 Feb 2023 01:35:47 +0800

起因是因为 Zathura作为一款我很喜欢的使用键盘移动的PDF阅读器, 居然拥有如此糟糕的划词功能(Text Select), 其划词功能通过一个方框框选出一片区域, Zathura自动提取出其中的文本, 并自动复制到剪贴板, 看上去很美好但是存在两个问题:

选区粒度粗, 不能做到精准到某个字符
划词不准确, 有时候阅读PDF文章时, 框出来的内容要么会变得很多要么缺胳膊断腿

网络实验复杂组网

Sat, 14 Jan 2023 00:51:29 +0800

实验内容

本实验将模拟一个全国范围的银行主干网络, 采用总行数据中心、省行和地市行的三级架构，业务接入基于MPLS VPN体系结构进行部署。充分考虑网络的安全性和可靠性规划网络拓扑结构，根据业务接入需求统一规划VPN、IP地址和子网，采用设备备份、链路备份、路由备份等技术保证网络的可靠性。

实验分析

体系架构

实验的主干网将分为4个自治系统, 所有的业务均采用VPN方式接入骨干网, 网络拓扑结构如下所示:

网络实验MPLS/VPN

Sun, 08 Jan 2023 23:55:43 +0800

~~偷懒偷的都是自己的懒… 虽然考完试了, 但是之前没有整理MPLS/VPN的内容, 确实对这块不敢说是很清楚…~~

在此之前

曾经尝试了更新系统来修复打开chrome/任务管理器卡死的问题, 当时就提示说此次更新与vmware冲突, 需要卸载vmware… 事实上确实与别的虚拟化平台会冲突.. 不仅仅是vmware, 还有vbox… 不过因为一直没有再次进入过ensp所以今天才发现..

Win11 开机后 Chrome 卡死: BIOS RAID 模式问题排查记录

Sun, 08 Jan 2023 22:20:12 +0800

Windows11 在某一天忽然出现了开机后首次打开 Chrome 等应用时整个系统卡死的问题, 经过大量的排查以及机缘巧合, 最终定位到是因为笔记本自行更换过硬盘, 导致与 BIOS 中默认的硬盘控制器模式 RAID ON 不兼容.

由于该卡死的问题并未在更换硬盘后立刻出现, 而是正常使用系统一段时间后忽然出现的问题; 同时, 由于我的笔记本同时运行 Linux 与 Win11 双系统, 仅在 Windows 系统上出现该问题. 因此在排查初期, 怀疑过是否是 Windows 系统中了病毒、软件自身等问题, 并未将目光聚焦到可能的硬件问题上.

本文简单梳理一下整体的时间线作为记录, 并给出问题最终的解决方案.

trash:取代危险的rm

Sun, 01 Jan 2023 13:23:27 +0800

rm 指令十分的危险… 为此希望实现一个回收站. archwiki给出了一些可用的建议 Trash management, 用下来体验不好, 打算自己搞一个.

第一版的trash自己解析了输入的参数.. 然后加上unix时间戳后mv到一个指定的公共磁盘分区上(因而其实性能也不太好, 尤其是大文件的删除时), 但是最后还是死在了处理空格和引号之类的问题上.. 而且与原生rm的兼容性不好…

Linux文件权限

Sun, 01 Jan 2023 12:48:34 +0800

其实对于Linux的文件权限一直一知半解, 之前使用php尝试访问sqlite的时候就发生了文件权限的惨案, 至今也不知道为什么会这样.. 当时的情况是, 将博客的public文件夹放置在服务器的/usr/share/nginx/html下就会G, 哪怕对数据库文件+该文件所在的目录都设置了777权限后php还是无法访问该目录下的sqlite DB; 修改放置位置到/srv/http/下就可以了, 而且不需要设置777, 设置为755即可.. 但是其实之前也考虑到文件权限等等, 因而将nginx和php-fpm的用户全部设置为了rqdmap, 而public文件的用户和组也全部都是rqdmap… 为何放到/srv下就可以了呢… 疑案未决…

因而准备稍微系统看一下Linux的文件权限管理.

实现Hit Counter访客统计

Mon, 19 Dec 2022 14:43:40 +0800

找了下网络上的但是不是很满意… 所以打算自己通过前后端实现一下Hit Counter来进行访客统计. 后端总体通过nginx + php-fpm + sqlite实现.

网络实验(MPLS基础与考试)

Mon, 19 Dec 2022 12:20:09 +0800

将所有的图片放在一个Markdown中太傻逼了, 超过了200张图片, 因而本篇博客再单独记录MPLS与网管的相关内容, 同时努力不再采用图片格式, 而是用Plain Text展示相关实验内容.

不过比较怠惰, MPLS VPN只是结合着教材上做了一下实验, 没有进行记录; 网管则是觉得过于傻逼, 加上ensp也没有网管软件, 很多报文都没法复现, 直接跳过不管.

vim使用技巧

Mon, 12 Dec 2022 23:34:58 +0800

不知道怎么就放弃了VSC… 极为朴素的用了3个月Vim… 最近越发觉得不能够得心应手的进行编辑了, 因而感觉是时候系统地再精进一下Vim了

首先记一下VSC的一些问题…

完全的OSS版本中, 许多插件都没有上线, 这样的VSC几乎无法使用了, 或许有什么奇技淫巧可以离线安装, 但是如果使用vsc还要折腾这么麻烦的话就偏离了使用它的初衷了; 而在微软的专有软件中(也是从官网上直接下载的版本), 插件有时候会有莫名的问题, 在我的archlinux上至少有如下两个问题, 感觉是比较大的瑕疵:

trojan+nginx共用443端口

Thu, 08 Dec 2022 19:41:35 +0800

当远端服务器的443与80端口已经运行着Http Server后, 如何复用端口以允许trojan同样监听443呢?

Linux下为Chrome开启代理

Wed, 07 Dec 2022 23:00:56 +0800

由于没有使用集成的桌面环境, 因而chrome没法读取全局代理的信息, 每次更新AUR chrome后都需要手动修改对应的桌面文件… 这里小小mark一下解决办法, 并给出 ALPM 钩子代码

命令行配置代理

Rofi命令行启动的应该是桌面程序(?), 在这个地方:/usr/share/applications/google-chrome.desktop

网络实验(OSPF,BGP与组播)

Sun, 27 Nov 2022 18:14:25 +0800

本文章包含200张图片… 请务必慎重打开该文章…

该博客主要为网络实验的全面复盘, 包括: OSPF, BGP, 组播, 网络管理与MPLS.

参考了大量张力军老师的《计算机网络实验教程》, 通过ensp进行各项实验与分析.

~~后记, 本博客OSPF和组播的介绍比较系统比较好, 但是BGP不知道当时在整理的时候处于什么精神状态, 导致BGP的内容整理比较答辩…~~

Stratovirt + Unikraft + Redis

Sat, 19 Nov 2022 18:26:34 +0800

尝试在stratovirt虚拟机上运行基于unikraft的redis, 并测试1G内存可以运行多少个实例, 但是行百里者半九十, 折腾了半天的网桥和DHCP, 又换了红帽, arch和debian系列的rootfs, 最终ubuntu总算把kraft成功build起来, 结果最后一步死活不行, 所以姑且记录一下, 但是意义寥寥…

ULK 中断与异常

Sat, 03 Sep 2022 19:41:12 +0800

中断被定义为一个事件, 该事件将改变处理的指令执行顺序.

中断分为同步中断和异步中断, 在Intel微处理器手册中, 它们分别被称为异常和中断.

中断是由定时器或IO设备产生的; 而异常是由程序的错误产生的, 或是由内核必须处理的异常条件(如缺页, 对内核服务的请求等)产生的, 前者内核通过发送信号来处理, 后者则需要内核执行恢复异常的所有步骤.

ULK 内存管理

Fri, 29 Jul 2022 19:50:44 +0800

页框管理

尽管奔腾处理器允许采取两种不同大小的页框:4KB和4MB(PAE被激活则是2MB),但是Linux采用4KB页框大小作为基本分配单元，基于两个原因:

由分页单元引发的缺页异常很容易得到解释:或者是页无权访问，或者是页不存在。在后一种情况下，内存分配器仅仅需要找到一个4KB空闲页框分配给进程。

6.828(2021)

Tue, 17 May 2022 19:56:46 +0800

代码存放于 rqdmap/6.828-2021下的各个Branch中

Trap

RISC-V的trap机制

在RISC-V中，使用ecall、发生exception和产生中断会使得CPU的控制流改变，转而去执行特殊任务以处理这些事件,这些事件被称为trap.

为了完成trap处理事件,RSIC-V CPU提供了一系列控制寄存器,其中比较重要的有以下几个:

Promela初探

Mon, 29 Nov 2021 18:44:41 +0000

由于要处理协议分析的大作业，接触了spin和Promela，下面整理一些内容作为记录。

基础语法

参考资料：

Promela-维基百科

Promela-Manual

数据类型

内置的基础类型有：bit(u1), bool(u1), byte(u8), short(16), int(32)等，这里前缀u表示无符号数。

声明一个变量可以类Ctypename name [ = anyexpr ]), 也可以使用这种语法unsigned name : constant [ = anyexpr ], 这样将声明一个占用conststant位的无符号数。当初始化的值超出了数据类型能表示的范围后，数值将会被截断造成信息的损失，spin只会在随机或指定的模拟下会警告该情况。

C内联汇编-AT&T

Wed, 13 Oct 2021 23:02:19 +0000

GCC-Inline-Assembly-HOWTO

GCC 汇编语法

GCC采用AT&T的汇编语法，这和intel汇编语法有一些不同：

操作数的顺序。intel语法通常是op dst src，在AT&T语法中则是op src dst
寄存器命名时需要加上%作为前缀
立即数的表示。AT&T立即数以$作为前缀，对于字符串常量而言也需要加上该前缀。intel语法中使用h后缀表示一个十六进制数，AT&T使用前缀0x表示。因而当表示一个十六进制的立即数时，则写为$0x123的格式
操作符的大小。AT&T中使用操作符后缀来确定该被作用的操作数的长度，‘b’, ‘w’, ’l’分别表示byte(8-bit), word(16-bit), long(32-bit)；在intel汇编中则是通过ptr作用在操作数上确定对应的长度
地址操作数。在间接寻址时，intel使用[base + index*scale + disp]的语法，在AT&T中则使用disp(base, index, scale)的语法。需要注意，当disp/scale中出现常量时，不需要$前缀。

基础语法

1asm("assembly code");

如果asm关键字与代码中其余部分冲突，也可以使用__asm__指令，二者是等价的。

ULK 进程

Mon, 04 Oct 2021 16:28:14 +0000

进程、轻量级进程和线程

进程是资源分配的实体，而线程是作业调度的基本单位。Linux使用轻量级进程来支持多线程应用程序，轻量级进程之间可以共享一部分资源，诸如地址空间、打开的文件等，通过将轻量级进程和线程关联起来就可以实现多线程应用程序。

进程描述符

进程描述符包含了与一个进程有关的所有信息，内容相当复杂。

进程拥有多种特殊资源，本章主要说明两种字段：进程的状态和进程间的父子关系。

ULK 内存寻址

Mon, 04 Oct 2021 16:28:08 +0000

绪论

绪论中从总体的框架介绍了一下操作系统、文件系统与Unix内核相关内容，不予过多赘述。

一个新学到的内容是可重入(内核，这意味着多个进程可以同时在内核下执行。这个特性太过于自然以至于让我一直没有注意到~~也没有在教材上见过~~，如果某个进程在内核态中被阻塞被挂起，那么它当然不应该影响到其余进程对CPU的使用。在可重入内核的要求下，内核控制路径就会被交替执行。

SEU夏令营回忆录_and_近况杂谈

Thu, 09 Sep 2021 22:58:25 +0000

对一个月前的东南大学夏令营的回忆，并杂乱地记录一些近日杂谈..

前言

现在电脑出了点问题都不知道是哪里爆炸了，有可能是挫比linux系统爆炸，有可能是挫比typora for linux兼容性不行，有可能是老键盘连接不稳定，还有可能自己误操作…….为了正确写个mardown还重启了电脑…

更新博客一拖再拖…当初面试完SEU后基本就彻底躺平，一直没有高兴记录博客；加上各种夏令营的具体情况理论上不得外传，显然不能发在部署在github的公开网页中，又想捣鼓有一下自定义theme的web前端后端技术，不过终归是无功而返…中断的嵌套层数太多，让人彻底失去一项项补全的耐心了，也就一拖到底了 ~~主要是打游戏躺平不香吗~~

iie夏令营记

Sat, 31 Jul 2021 00:15:16 +0000

iie（伪）夏令营记

LinuxKernel

Sat, 17 Jul 2021 22:09:30 +0000

深入理解Linux内核学习笔记

前言

想要学习Linux内核的契机大抵源于读OS相关的paper时感到力不从心，就正好趁机学习一下素来感兴趣的内核知识。

写下“兴趣”二字后不禁想到日向晶也的论述，兴趣绝不能成为训练的动力，否则遇挫后兴趣消失也就自然放弃了训练；然而学习内核确实也没有什么迫切的压力与强制的要求，随意为之吧

ECNU夏令营记

Tue, 13 Jul 2021 23:35:04 +0000

华东师范大学计算机营游记

BUAA夏令营记

Mon, 12 Jul 2021 21:45:48 +0000

BMP-FS

Fri, 28 May 2021 20:14:56 +0000

BMP文件格式初探

实现BMP文件的放缩

搜索资料时找到，笑死。

此为课程设计的第四题,这道题体现了大作业的精髓:在抄中知道，在抄中学习，在抄中苟且。

BMP 文件结构

一般的情况如下所示，摘自 wiki

Structure name	Optional	Size	Purpose	Comments
Bitmap file header	No	14 bytes	To store general information about the bitmap image file	Not needed after the file is loaded in memory
DIB header	No	Fixed-size (7 different versions exist)	To store detailed information about the bitmap image and define the pixel format	Immediately follows the Bitmap file header
Extra bit masks	Yes	3 or 4 DWORDs[ 6] (12 or 16 bytes)	To define the pixel format	Present only in case the DIB header is the BITMAPINFOHEADER and the Compression Method member is set to either BI_BITFIELDS or BI_ALPHABITFIELDS
Color table	Semi-optional	Variable size	To define colors used by the bitmap image data (Pixel array)	Mandatory for color depths ≤ 8 bits
Gap1	Yes	Variable size	Structure alignment	An artifact of the File offset to Pixel array in the Bitmap file header
Pixel array	No	Variable size	To define the actual values of the pixels	The pixel format is defined by the DIB header or Extra bit masks. Each row in the Pixel array is padded to a multiple of 4 bytes in size
Gap2	Yes	Variable size	Structure alignment	An artifact of the ICC profile data offset field in the DIB header
ICC color profile	Yes	Variable size	To define the color profile for color management	Can also contain a path to an external file containing the color profile. When loaded in memory as “non-packed DIB”, it is located between the color table and Gap1.[ 7]

一般来说，现在获取到的BMP文件的DIB头都是第五代(BITMAPV5HEADER)，长124字节；但是针对本实验而言，只需要极少的一些信息，因而只保留40字节，剩余84字节读进来不与使用。

qko-gym

Fri, 02 Apr 2021 21:10:37 +0000

Day1

hdu6643

因为例题不仅有点分治还涉及到了树上依赖背包的算法，才发现自己并不太会树形背包的若干优化算法，故学习。

树形背包

模板题

给出一颗依赖树，询问总重量限定下可能获得的最大价值。

物品的数量和重量的限制均不超过100

有不同的做法，复杂度也不同。

向上合并

随意采取$O(nm^2)$的算法即可在树上合并。

arc-116

Sun, 28 Mar 2021 21:54:52 +0000

~~自以为A了一道精妙的DP题结果被第二道同样思想的DP卡死~~

D 总和给定下进行NIM必败态计数

给出n、m，表示总共有n堆可空石堆$ {a_i}$，要求满足$\sum a_i = m, \bigoplus a_i=0$，查询这样的序列的个数。

感觉上可以称之为非常经典的题目。

设置dp状态：dp[i]表示n堆石子和为i，异或和为0的序列数量。

linux多线程

Tue, 23 Mar 2021 12:45:36 +0000

在linux下，Pthread是一套通用的线程库，由POSIX提出，具有较好的移植性。

使用头文件<pthread.h>

线程基本操作

线程的创建与退出

pthead_create

1int pthread_create(pthread_t *thread, pthread_attr_t * attr, void *(*start_routine)(void *), void *arg);

传入参数：thread为线程标识符，attr为线程属性设置，start_routine为线程函数起始地址，arg为传给start_routine的参数。

Linux 下的 socket 编程

Tue, 23 Mar 2021 12:45:29 +0000

基础知识

socket常用函数

socket

domain指定协议族，type指定socket类型，protocol指定协议（为0时自动选择type类型对应的默认协议）

1int socket(int domain, int type, int protocol);

返回值大于0成功；-1失败，错误类型保存在全局变量errno中。

bind

分配地址族中的特地地址给socket sockfd为socket描述字，通过socket函数的返回值确定 addr指向绑定给sockfd的地址，根据socket创建时协议族的不同而不同。

gym-102956

Sun, 21 Feb 2021 17:16:43 +0000

线段树扩展

Thu, 18 Feb 2021 16:42:07 +0000

edu-104-div2

Tue, 16 Feb 2021 01:05:12 +0000

被set爆锤的一场

如果自定义了比较符，那么应该要仔细的审查比较符的定义是否符合预期！特别是两个对象相等的情况！

不然在进行set.erase()/set.insert()时会出现头de烂都看不出来的的bug

CF-699-div2

Sat, 06 Feb 2021 19:59:44 +0000

点分树

Fri, 05 Feb 2021 18:27:17 +0000

P6329 点分树模版震波

点分治

Mon, 01 Feb 2021 19:11:48 +0000

cdq初步

Mon, 01 Feb 2021 18:16:42 +0000

cdq分治三维偏序问题

2020-2021Brazil-Subregional-Programming-Contest

Thu, 28 Jan 2021 21:51:34 +0000

poj-1222

Mon, 18 Jan 2021 21:56:04 +0000

给出一个5*6的01矩阵，每按一个格点就会将该格点及其4个方向上的格点（如果有的话）数值翻转，试给出一个方案使得最终所有格点均为0.

2021-XDU-寒假训练

Sun, 17 Jan 2021 15:47:57 +0000

块状DS

Sat, 16 Jan 2021 14:08:28 +0000

2020数据库实验

Fri, 15 Jan 2021 23:04:14 +0000

前端使用html，后台使用mysql数据库，使用php处理数据库，完成数据库课程的学籍管理系统大作业。

特此记录，有机会的话还是希望学习一番全栈的内容。

~~别的班好像做的都绘声绘色的，我们班验收者则寥寥，我太菜了~~

前台html服务

写的非常丑陋，很多冗余的代码，自己确实完全是个门外汉qaq

~~没有css 我不会~~

CF-edu102

Fri, 15 Jan 2021 20:03:50 +0000

Educational Codeforces Round 102 (Rated for Div. 2)

微信小程序

Mon, 07 Dec 2020 23:44:05 +0000

记一次微信小程序的搭建过程。

前端wxml+wxss+js，后端apache2+php+mysql

尽管为了完成微信小程序的基本功能只需要略知上述内容的皮毛即可，但是从零开始仍然是过程坎坷，花费了许多夜晚才略有成效；故特此记录。

后端apache服务器的配置

apache2

最初不知道从哪里安装了一个不带有mysqli库的apache2，导致我顶着超长的延迟在服务器修了一年还是不知道怎么搞出来。

2020-ccpc-weihai

Sat, 21 Nov 2020 22:05:14 +0000

G 线段树区间修改、取模，区间哈希和查询

需要维护一个支持区间加1并对固定模数取模、区间哈希查询的线段树

开局就想写的一道题，写到最后艰难调出来后wa7，最终放弃上机辅助队友看别的题

晚上回去又调了很久，发现了几个错误

线段树哈希写错了，在求哈希和的时候不像普通的线段树区间和一样，查询哈希和时查询的区间[L, R]是需要动态变化的，必须保证L被不断地截断，才能保证算法的正确性
眼睛比较瞎，前缀和pre[]对M(65536)取模了
最开始的purify(将那些超过65536的位置取模)写挫了，在终止条件(l == r)之前就调用了down函数。调了一年才发现原来是这里有问题：如果在终止条件之前就调用down函数，这会导致地址的越界访问。因为st只开了4倍空间，所以如果在那种边角叶子结点（在满二叉树上多一个节外生枝的结构）仍然尝试down下去，就会访问到8倍的位置！在CF居然没有发生RE报警，以至于我一度怀疑是自己算法写错了，其实是空间的计算错误导致了UKE。

cpp

  1#define ls (p << 1)
  2#define rs ((p << 1) | 1)
  3#define mid ((l + r) >> 1)
  4
  5using namespace std;
  6const int maxn = 5e5 + 10;
  7const int M = 65536;
  8
  9const int pp = 999983;
 10const int mod = 1000237529;
 11
 12int a[maxn];
 13ll tag1[maxn << 2], st2[maxn << 2], st[maxn << 2];
 14ll po[maxn], pre[maxn];
 15
 16void up(int p, int l, int r){
 17    st[p] = st[ls] + st[rs] * po[mid - l + 1] % mod; st[p] %= mod;
 18    st2[p] = max(st2[ls], st2[rs]);
 19}
 20
 21void build(int p, int l, int r, int k, int x){
 22    if(l == r && l == k){
 23        st[p] = st2[p] = x;
 24        return ;
 25    }
 26    if(k <= mid) build(ls, l, mid, k, x);
 27    else build(rs, mid + 1, r, k, x);
 28    up(p, l, r);
 29}
 30
 31void down(int p, int l, int r){
 32    if(tag1[p]){
 33        tag1[ls] += tag1[p];
 34        tag1[rs] += tag1[p];
 35        
 36        st[ls] += pre[mid - l] * tag1[p] % mod; st[ls] %= mod;
 37        st[rs] += pre[r - mid - 1] * tag1[p] % mod; st[rs] %= mod;
 38        
 39        st2[ls] += tag1[p];
 40        st2[rs] += tag1[p];
 41        
 42        tag1[p] = 0;
 43    }
 44}
 45
 46void update(int p, int l, int r, int L, int R){
 47    if(L <= l && r <= R){
 48        st[p] += pre[r - l]; st[p] %= mod;
 49        st2[p]++; tag1[p]++;
 50        return ;
 51    }
 52    down(p, l, r);
 53    if(L <= mid) udpate(ls, l, mid, L, R);
 54    if(R > mid) update(rs, mid + 1, r, L ,R);
 55    up(p, l, r);
 56}
 57
 58void purify(int p, int l, int r){
 59    if(st2[p] < M) return;
 60    down(p, l, r);
 61    if(l == r){
 62        st[p] %= M; st2[p] %= M;
 63        return ;
 64    }
 65    
 66    if(st2[ls] >= M) purify(ls, l, mid);
 67    if(st2[rs] >= M) purify(rs, mid + 1, r);
 68    up(p, l, r);
 69}
 70
 71ll hsh(int p, int l, int r, int L, int R){
 72    if(L <= l && r <= R) return st[p];
 73    down(p, l, r);
 74    
 75    if(R <= mid) return hsh(ls, l, mid, L, R);
 76    else if(L > mid) return hsh(rs, mid + 1, r, L, R);
 77    else{
 78        ll ans = hsh(ls, l, mid, L, mid);
 79        ans += hsh(rs, mid + 1, r, mid + 1, R) * po[mid - L + 1] % mod;
 80        ans %= mod;
 81        return ans;
 82    }
 83}
 84
 85int main(){
 86//   Fastin;
 87    po[0] = 1;
 88    for(int i = 1; i < maxn; i++) po[i] = po[i - 1] * 1ll * pp % mod;
 89    pre[0] = 1;
 90    for(int i = 1; i < maxn; i++) pre[i] = pre[i - 1] + po[i], pre[i] %= mod;
 91    
 92    int n, m; scanf("%d %d", &n, &m);
 93    for(int i = 1; i <= n; i++){
 94        scanf("%d", a + i);
 95        build(1, 1, n, i, a[i]);
 96    }
 97    
 98    while(m--){
 99        int op; scanf("%d", &op);
100        if(op == 1){
101            int l, r; scanf("%d %d", &l, &r);
102            update(1, 1, n, l, r);
103        }
104        else{
105            int l, r, k; scanf("%d %d %d", &l, &r, &k);
106            purify(1, 1, n);
107            
108            ll res1 = hsh(1, 1, n, l, l + k - 1);
109            ll res2 = hsh(1, 1, n, r, r + k - 1);
110            puts(res1 == res2? "yes": "no");
111        }
112    }
113
114    return 0;
115}

L 分组背包 & LCM

给出n，构造某种拆分$p_1+p_2+…+p_k = n$，使得$lcm(p_1, p_2, …, p_k)$最大。

opencup-gym102391

Wed, 11 Nov 2020 20:15:51 +0000

J RQD-IGVA树树上DSU

最开始以为险段长度跟n无关，所以加了根[1, n]的线段进去就WA到死，后来改成[1, 1000000]即可。

大概是叫dsu on tree，可以处理一些与子树有关的询问，复杂度Onlogn

~~可惜IGVA不知道场上什么地方写挫了场后10分钟A了~~

cpp

 1const int maxn = 3e5 + 10;

 3int n, w[maxn];
 4struct star{int to, next;};
 5int head[maxn], top = 0;
 6star edge[maxn];
 7void add(int u, int v){
  edge[top].to = v;
  edge[top].next = head[u];
  head[u] = top++;
11}

13struct NODE{
  int l, r, w;
  bool operator < (const NODE &b) const{
      if(l != b.l) return l < b.l;
      else return r > b.r;
  }
19};
20vector<NODE> vec;
21priority_queue<ll> pq[maxn];
22int conv[maxn];
23vector<ll> temp;

25//合并边i和边j的优先队列，放到i里面
26void merge(int i , int j){
  temp.clear();
  if(pq[conv[i]].size() < pq[conv[j]].size()) swap(conv[i], conv[j]);

  while(!pq[conv[j]].empty()){
      temp.push_back(pq[conv[i]].top() + pq[conv[j]].top());
      pq[conv[i]].pop(); pq[conv[j]].pop();
  }
  for(auto x: temp) pq[conv[i]].push(x);
35}

37void sove(int now){
  for(int i = head[now]; ~i; i = edge[i].next){
      sove(edge[i].to);
      merge(now, edge[i].to);
  }
  pq[conv[now]].push(vec[now].w);
43}

45stack<int> sta;

47int main(){
  // Fastin;
  clr(head, -1);
  scanf("%d", &n);
  for(int i = 1; i <= n; i++){
      int u, v, w; scanf("%d %d %d", &u, &v, &w);
      vec.push_back({u, v, w});
  }
  vec.push_back({1, 1000000, 0});
  sort(vec.begin(), vec.end());

  sta.push(0);
  for(int i = 1; i <= n; i++){
      int top = sta.top();
      while(!(vec[top].l <= vec[i].l && vec[i].r <= vec[top].r)){
          sta.pop(); 
          if(sta.empty()){while(1);};
          top = sta.top();
      }
      add(top, i); sta.push(i);
  }

  for(itn i = 0; i <= n; i++) conv[i] = i;
  sove(0);

  ll ans = 0;
  for(int i = 1; i <= n; i++){
      if(!pq[conv[0]].empty()){
          ans += pq[conv[0]].top(); pq[conv[0]].pop();
      }
      printf("%lld ", ans);
  }

  return 0;
81}

I 最小直径生成树 MDST

为了求解MDST，就需要求解绝对中心所在的位置。绝对中心不一定在节点上，可以在边上。

chanllage

Tue, 03 Nov 2020 22:21:00 +0000

有一些有趣但是大概需要高深数学知识的计算机问题悬而未决，特此记录。

张帆猜想

哈希冲突概率

有等式$(a_1^k+a_2^k+…+a_n^k) % 2^{64}=(b_1^k+b_2^k+…+b_n^k)% 2^{64}$，

定义“冲突“为：满足上述等式的两个多重集合{an}{bn}不完全相同。

希望说明：当n为1e5的级别时，k=2时冲突概率极高，而当k>=3时冲突的概率就会降低到一个可以接受的程度。

2020-ccpc-qinhuangdao

Wed, 28 Oct 2020 19:23:04 +0000

K 树dp

场上想了一个不太对的排序办法，真正的排序方法应该是将子树按照最深深度从低到高进行排序。然后随便维护一个dp数组表示从根节点派遣若干士兵遍历完i子树所需要的最小时间，每次尝试用子树的结果更新他们共同父节点的信息：

如果某节点是叶子，那么用其深度作为结果；
如果某节点不是叶子，将子树按照上述顺序排序后，考虑子树v1可能对v2造成的贡献：当height[v1] + 2 <= dep[v2]，那么从v1的士兵原路返回会比重新派遣一个人过来更优，将结果减去差值，不断重复更新。每次只需要考虑子树$i$对子树${i + 1}$的贡献，这是因为子树序列是单调的，一旦到某个位置后重新派遣更优，之后的所有位置也一定是重新派遣更优。

cpp

 1const int manx = 1e6 + 10;
 2
 3struct star{int to, next;};
 4int head[maxn], top = 0;
 5star edge[maxn << 1];
 6
 7void add(int u, int v){
 8    edge[top].to = v;
 9    edge[top].next = head[u];
10    head[u] = top++;
11}
12
13int dep[maxn], height[maxn];
14void dfs(int x, int par){
15    height[x] = 0; 
16    for(int i = head[x]; ~i; i = edge[i].next){
17        int to = edge[i].to; if(to == par) continue;
18        dep[to] = dep[x] + 1;
19        dfs(to, x);
20        height[x] = max(height[x], height[to] + 1);
21    }
22}
23
24//从根结点派遣若干人，遍历完i子树所需要的最小代价即为dp[i]
25bool cmp(int x, int y){return height[x] < height[y];}
26ll dp[maxn];
27void sove(int now, int par){
28    vector<int> vec;
29    for(int i = head[now]; ~i; i = edge[i].next){
30        itn to = edge[i].to; if(to == par) continue;
31        vec.push_back(to);
32        sove(to, now);
33    }
34    sort(vec.begin(), vec.end(), cmp);
35    if(vec.empty()) dp[now] = dep[now];
36    else{
37        int top = (int)vec.size();
38        for(auto x: vec) dp[now] += dp[x];
39        fro(int i = 1; i < top; i++){
40            if(height[vec[i - 1]] + 2 <= dep[vec[i]]){ 
41                dp[now] -= dep[vec[i]] - height[vec[i - 1]] - 2;
42            }
43        }
44    }
45}
46
47int main(){
48    // Fastin;
49    int _; scanf("%d", &_); fro(int __ = 1; __ <= _; __++){
50        top = 0;
51        int n; scanf("%d", &n);
52        for(int i = 1; i <= n; i++){
53            dp[i] = height[i] = dep[i] = 0;
54            head[i] = -1;
55        }
56        for(int i = 2; i <= n; i++){
57            int x; scanf("%d", &x);
58            add(x, i); add(i, x);
59        }
60        dfs(1, 0);
61        sove(1, 0);
62        printf("Case #%d: %d\n", __, dp[1]);
63    }
64    return 0;
65}

J 哈希与组合数学

感谢冯佬的指点qaq 不然我可能一年都调不出来这题…sro flukehn….

2019-SWERC

Sat, 17 Oct 2020 00:09:31 +0000

参考博客：

https://www.cnblogs.com/heyuhhh/p/12941654.html

K 图上的路径存在问题(?) ->建反图进行染色

建反图，用rot的每个邻点去对整张图染色，被染色的点就意味着可以走到该颜色所代表的邻点。我们允许每个点最多被染色两次，这是因为rot的邻点一旦被超过一个点染色，那么就一定不合法；所以对图中每个点而言，如果其被染色次数大于等于2，那么其出边所对应的一系列点的更新也已经都完成，再次染色增加染色次数没有任何意义，并不会改变“不合法”这一性质。

2019-icpc-taipei

Sun, 04 Oct 2020 22:07:24 +0000

I 已知两数差，求所有可能的原本的序列

原序列长度小于等于62，序列值小于1000且两两不同。

如果已经还原出了原序列中的$i$个值，那么除去这i个值两两的差之后，差值集合中最大的数便可以基本确定下来：这个数一定是原序列中的某个数与a[1] = 0或者a[n]作差得到的，这点由“最大”保证。

那么检查这个最大的数出现的次数，如果次数超过2，则不满足两两不同的要求；如果次数为2，直接根据a[1], a[n]可以更新两个值进行原序列；如果次数仅为1，则需要分别递归考虑一番。

办公楼biu

Fri, 04 Sep 2020 20:13:53 +0000

给出一张图，求出其补图所有联通块的个数及其大小。

黑暗爆炸OJ 1098

容易想到$O(n^2)$的算法：对于每一个点，枚举所有邻点打上标记，然后找那些没有被打上标记的点，将这些点加入到一个联通块中。

如果使用链表，可以将复杂度优化到$O(n + m)$，非常的神奇。

~~本来是非常的神秘，后来qko学长给我讲了下就变得非常神奇了 orz~~

24point

Wed, 02 Sep 2020 22:31:00 +0000

24点小游戏~

cpp

  1#include <iostream>
  2      
  3#include <algorithm>
  4#include <string>
  5#include <vector>
  6#include <stack>
  7#include <queue>
  8#include <set>
  9#include <map>
 10#include <unordered_map>
 11#include <unordered_set>
 12#include <random>
 13#include <chrono>
 14     
 15#include <cstdio>
 16#include <cstring>
 17#include <cmath>
 18#include <ctime>
 19#include <cstdlib>
 20#include <cassert>
 21      
 22#define itn int
 23#define fro for
 24#define scnaf scanf
 25#define sacnf scanf
 26#define manx maxn
 27#define pritnf printf
 28
 29#define Fastin freopen("in.txt", "r", stdin)
 30#define Fastout freopen("out.txt", "w", stdout)
 31#define min(a, b) ((a) < (b)? (a): (b))
 32#define max(a, b) ((a) > (b)? (a): (b))
 33#define lowbit(x) ((x) & (-x))
 34#define ceil(n, p) (((n) +(p) - 1) / (p))
 35#define DBG(x) (void)(cout << "L" << __LINE__ << ": " << #x << " = " <<( x) << '\n')
 36#define clr(a, x) memset((a), x, sizeof (a))
 37#define TTT int __; scanf("%d", &__); while(__--)
 38using namespace std;
 39typedef long long ll;
 40
 41int a[5], b[5], p[5];
 42
 43struct NODE{
 44    string s; double w;
 45    bool operator < (const NODE& b)const{return s < b.s;}
 46};
 47set<NODE> s[5][5];
 48//处理[left, right]的值
 49void sove(int left, int right){
 50    if(left > right) return ;
 51    if(left == right){
 52        NODE temp;
 53        temp.s = to_string(a[left]); temp.w = a[left];
 54        s[left][right].insert(temp);
 55        return;
 56    }
 57    for(int i = left; i <= right - 1; i++){
 58        sove(left, i); sove(i + 1, right);
 59        NODE temp;
 60        for(auto x: s[left][i]) for(auto y: s[i + 1][right]){
 61            temp.s = x.s; if(left != i) temp.s = "(" + temp.s + ")";
 62            temp.s += "+"; temp.w = x.w + y.w;
 63            if(i + 1 != right) temp.s += "(" + y.s + ")";
 64            else temp.s += y.s;
 65            s[left][right].insert(temp);
 66            
 67            temp.s = x.s; if(left != i) temp.s = "(" + temp.s + ")";
 68            temp.s += "-"; temp.w = x.w - y.w;
 69            if(i + 1 != right) temp.s += "(" + y.s + ")";
 70            else temp.s += y.s;
 71            s[left][right].insert(temp);
 72            
 73            temp.s = x.s; if(left != i) temp.s = "(" + temp.s + ")";
 74            temp.s += "*"; temp.w = x.w * y.w;
 75            if(i + 1 != right) temp.s += "(" + y.s + ")";
 76            else temp.s += y.s;
 77            s[left][right].insert(temp);
 78            
 79            if(y.w == 0) continue;
 80            temp.s = x.s; if(left != i) temp.s = "(" + temp.s + ")";
 81            temp.s += "/"; temp.w = x.w / y.w;
 82            if(i + 1 != right) temp.s += "(" + y.s + ")";
 83            else temp.s += y.s;
 84            s[left][right].insert(temp);
 85        }
 86        
 87    }
 88}
 89
 90const double eps = 1e-6;
 91set<string> ans;
 92
 93int main(){
 94//    Fastin;
 95    for(int i = 1; i <= 4; i++) scnaf("%d", b + i);
 96    p[1] = 1; p[2] = 2; p[3] = 3; p[4] = 4;
 97    
 98    do{
 99        for(int i = 0; i < 5; i++) for(int j = 0; j < 5; j++) s[i][j].clear();
100        for(int i = 1; i <= 4; i++) a[i] = b[p[i]];
101        sove(1, 4);
102        for(auto x: s[1][4]) if(abs(x.w - 24) <= eps){
103            ans.insert(x.s);
104        }
105    }while(next_permutation(p + 1, p + 5));
106    
107    if(ans.empty()) puts("-1");
108    else for(auto s: ans) cout << s << '\n';
109    return 0;
110}

2019-XDU-onsite

Wed, 02 Sep 2020 20:10:45 +0000

1427 qko的宝可梦（已补）

1428 qko的串

1429 qko的进化公式

1430 qko的树

1427 set对有序链的维护

set中每个节点拥有最小攻击力和最大攻击力，保证set中一定满足严格的偏序关系，即保证两个元素之间一定有某元素的最大值全部小于另一个元素的最小值。

初始将1号宝可梦插入到set中，然后遍历2-n宝可梦，通过lower_bound和upper_bound来获得set中“相等“的那些元素。这里的相等意味着不存在严格的偏序关系，那么也就意味着两者互相可以击败，从而这些元素都可以与第i个元素互相可达，应该合并成一个SCC。遍历所有这些相等的元素，将信息进行不断合并，最后将新元素再插入到set中，这样就可以保证set中的严格偏序关系，输出结果时将最后一个元素的个数输出即可。

2020-牛客多校-10

Tue, 25 Aug 2020 15:38:23 +0000

C 思维 & 树

C* Namomo 2C

区间减1，代价为长度的平方，问将区间操作为全0的最小代价和最大代价。

cpp

  1#include <iostream>
  2      
  3#include <algorithm>
  4#include <string>
  5#include <vector>
  6#include <stack>
  7#include <queue>
  8#include <set>
  9#include <map>
 10#include <unordered_map>
 11#include <unordered_set>
 12#include <random>
 13#include <chrono>
 14     
 15#include <cstdio>
 16#include <cstring>
 17#include <cmath>
 18#include <ctime>
 19#include <cstdlib>
 20#include <cassert>
 21      
 22#define itn int
 23#define fro for
 24#define scnaf scanf
 25#define sacnf scanf
 26#define Fastin freopen("in.txt", "r", stdin)
 27#define Fastout freopen("out.txt", "w", stdout)
 28#define manx maxn
 29#define lowbit(x) ((x) & (-x))
 30#define ceil(n, p) (((n) +(p) - 1) / (p))
 31#define DBG(x) (void)(cout << "L" << __LINE__ << ": " << #x << " = " <<( x) << '\n')
 32#define clr(a, x) memset((a), x, sizeof (a))
 33#define min(a, b) ((a) < (b)? (a): (b))
 34#define max(a, b) ((a) > (b)? (a): (b))
 35     
 36using namespace std;
 37typedef long long ll;
 38     
 39int read(){
 40   int ng=0,x=0;
 41   char ch=getchar();
 42   for(;ch<'0' || ch>'9';ch=getchar()) ng|=ch=='-';
 43   for(;ch>='0' && ch<='9';ch=getchar()) x=(x<<3)+(x<<1)+ch-'0';
 44   return ng?-x:x;
 45}
 46/*------------------------------------------------------------------------------------*/
 47ll gcd(ll x, ll y){return !x? y: gcd(y % x, x);}
 48void exgcd(ll a, ll b, ll &x, ll &y){
 49    if(!b){x = 1; y = 0;return;}
 50    exgcd(b, a % b, y, x); y -= a / b * x;
 51}
 52ll qp(ll a, ll p){
 53    if(p < 0) return 0;
 54    ll ans = 1; while(p){if(p & 1) ans = ans * a ; a = a * a; p >>= 1;}
 55    return ans;
 56}
 57ll qp(ll a, ll p, ll M){
 58    ll ans = 1; while(p){ if(p & 1) ans = ans * a % M; a = a * a % M; p >>= 1;}
 59    return ans;
 60}
 61/*------------------------------------------------------------------------------------*/
 62
 63const int maxn = 5e5 + 10;
 64const int M = 1e9 + 7;
 65int a[maxn], b[maxn];
 66
 67ll cal(int l, int r){return (r - l) * 1ll * (r - l) % M;}
 68
 69stack<pair<int, int>> sta;
 70
 71int main(){
 72//    Fastin;
 73    int n; scnaf("%d", &n);
 74    for(int i = 1; i <= n; i++) scanf("%d", a + i); a[n + 1] = 0;
 75    
 76    for(int i = 1; i <= n + 1; i++) b[i] = a[i] - a[i - 1];
 77    while(b[n + 1] == 0) n--;
 78    ll ans = 0;
 79    int p = 1, q = 1; while(b[q] >= 0) q++;
 80    while(p <= n + 1){
 81        if(b[p] + b[q] > 0){
 82            ans += -b[q] * cal(p, q); ans %= M;
 83            b[p] += b[q];
 84            q++; while(q <= n + 1 && b[q] >= 0) q++;
 85        }
 86        else if(b[p] + b[q] == 0){
 87            ans += b[p] * cal(p, q); ans %= M;
 88            p++; q++; while(p <= n + 1 && b[p] < 0) p++; while(q <= n + 1 && b[q] >= 0) q++;
 89        }
 90        else{
 91            ans += b[p] * cal(p, q); ans %= M;
 92            b[q] += b[p];
 93            p++; while(p <= n + 1 && b[p] < 0) p++;
 94            
 95        }
 96    }
 97    printf("%lld ", ans % M);
 98    
 99    for(int i = 1; i <= n + 1; i++) b[i] = a[i] - a[i - 1];
100    ans = 0;
101    for(int i = 1; i <= n + 1; i++){
102        if(b[i] > 0) sta.push({i, b[i]});
103        else if(b[i] < 0){
104            while(1){
105                pair<int, int> now = sta.top(); sta.pop();
106                if(now.second + b[i] < 0){
107                    ans += now.second * cal(now.first, i); ans %= M;
108                    b[i] += now.second;
109                }
110                else{
111                    ans += -b[i] * cal(now.first, i); ans %= M;
112                    now.second += b[i];
113                    sta.push(now);
114                    break;
115                }
116                
117            }
118        }
119    }
120    
121    printf("%lld\n", ans);
122    
123    return 0;
124}

I 构造

~~虽然感觉还是说不太清楚qaq~~

2020-hdu多校-3

Tue, 28 Jul 2020 20:11:40 +0000

1004 前缀和dp

预处理出前缀和，前缀和相同的两个点之间就可以合并成一个满足条件的数。

从后往前利用前缀和即可dp处理出最多的个数。

1009 模拟括号匹配

出现未配对的右括号就用最左边的*去匹配，出现未配对的左括号就用最右边的*去匹配。

~~差不多是这样~~

1005 并查集&计数

先统计一下所有点集在无边时的ans值，然后每连两个联通块，就将这两个联通块之间之前会产生的贡献全部减去即可。

2020-牛客多校-5

Mon, 27 Jul 2020 22:03:09 +0000

坑

I 数学构造题

想这类题的时候不能太过于从有限的角度去考虑无穷的角度，如果用有限的面积拓展到无限的面积，那么最多大概也就1/2, 5/9的情况，这不是最优的。应该用无限的观点去尝试构造，考虑一个金块最多可以贡献出4个信标，一个炼丹炉最多也可以贡献4个信标，并且认为这一个金块和一个炼丹炉都能在平均的意义下满足4个信标的放置条件，那么最好的情况就是4/6 = 2/3。

2020-牛客多校-6

Mon, 27 Jul 2020 20:09:49 +0000

有坑待补具体数学约瑟夫的Ok做法

B 线性无关的n维01向量个数

考虑每次加入元素时可取的元素个数。

假设当前已经取了i个线性无关向量，则它们可以张出一共$2^i$个向量，所以第i + 1个向量只有$2^n - 2 ^ i$种可取办法。

因而$f(n) = \prod_{i=0}^{n - 1}(2^n-2^i)/2^n$

推导可得递推关系:

$f(n) = (1 - 1/2^n)*f(n - 1)$

线性处理出来O1查询即可。

2020-hdu多校-2

Thu, 23 Jul 2020 19:44:48 +0000

6763 1001 并查集

题目出锅了虽然开局一堆人A的飞快，但是应该都是假算法？~~主要是出题人给的题解是假的~~

如果从每次都尽可能删除极大联通块的策略来考虑，那么可以用并查集维护信息。显然在一个极大联通块中可以将每个节点删去所有权值中的最小值，之后该点断裂，将原联通块分成若干个小联通块，反复进行上述操作即可。我们用并查集反向维护这个过程：将所有节点按照权值从大到小进行遍历，如果当前点$u$连有边$<u,v>$并且有$w[v] > w[u]$，那么就在并查集中连$<root[v]->u>$ 。这样，我们最终就会得到一颗有根树，其上节点的父子关系也给出了删去权值的方案。最终只需要用w[x] - w[par[x]]去更新答案即可。

2020-hdu多校-1

Wed, 22 Jul 2020 18:02:26 +0000

1006

cpp

  1const itn maxn = 1e5 + 10;
  2
  3int n, m, w[maxn];
  4struct star{int to, next;};
  5
  6int head[maxn], top = 0;
  7int du[maxn], K;
  8star edge[maxn << 1];
  9void add(int u, int v){
  edge[top].to = v;
  edge[top].next = head[u];
  head[u] = top++;
 13}
 14
 15unordered_map<int, int> mp[maxn];
 16unordered_map<int, int> conv;
 17
 18int c[700][maxn], bitcnt = 0, zero[maxn];
 19void add(int id, int i, int x, int n){
  while(i <= n){ c[id][i] += x; i += lowbit(i);}
 21}
 22int query(int id, int i){
  int ans = 0;
  while(i){ans += c[id][i]; i -= lowbit(i);} return ans;
 25}
 26
 27void bitupdate(int u, int key, int op){
  assert(conv.count(u) == 1);
  int id = conv[u]; add(id, key, op, du[u]);
 30}
 31
 32//将u节点的邻接权值key的数量 += op
 33void update(int u, int key, int op){
  if(key > du[u]) return;
  
  //特判断0
  if(key == 0){
      zero[u] += op; return;
  }
 40
  mp[u][key] += op;
  // 1 - >0
  if(mp[u][key] == 0){
      bitupdate(u, key, -1);
      mp[u].erase(key);
  }
  //0 -> 1
  if(mp[u][key] == 1 && op == 1) bitupdate(u, key, 1);
 49
 50}
 51
 52//检查u节点的邻点中 权值x及其之前是否填满
 53bool check(int u, int x){
  if(x == 0){
      if(zero[u] == 0) return 0;
      return 1;
  }
  int cnt = query(conv[u], x);
  return x == cnt;
 60}
 61
 62int temp[maxn];
 63int mex(int u){
  if(du[u] < K){
      for(int i = 0; i <= du[u]; i++) temp[i] = 0;
      for(int i = head[u]; ~i; i = edge[i].next){
          if(w[edge[i].to] > du[u]) continue;
          temp[w[edge[i].to]] = 1;
      }
      for(int i = 0; i <= du[u]; i++) if(!temp[i]) return i;
      return -1;
  }
  else{
      if(zero[u] == 0) return 0;
      
      int left = 0, right = du[u], middle;
      while(left < right){
          middle = (left + right) >> 1;
          if(check(u, middle)) left = middle + 1;
          else right = middle;
      }
      return left;
  }
 84}
 85
 86unordered_set<int> vec[maxn];
 87
 88struct NODE{
  int x, y;
  NODE(int _x, int _y){
      x = min(_x, _y);
      y = max(_x, _y);
  }
  bool operator <(const NODE &b)const{
      if(x != b.x) return x < b.x;
      else return y < b.y;
  }
 98};
 99set<NODE> EDGE;
100
101int main(){
102//    Fastin;
  int t; scanf("%d", &t); while(t--){
      clr(head, -1); top = 0; clr(du, 0); clr(zero, 0); bitcnt = 0;
      
      n = read(); m = read();
      
      for(int i = 1; i <= n; i++) mp[i].clear(); conv.clear();
      
      K = sqrt(m);
      for(int i = 1; i <= n; i++){
          w[i] = read(); vec[i].clear();
      }
      
      EDGE.clear();
      for(int i = 0; i < m; i++){
          int u, v; u = read(); v = read();
          EDGE.insert(NODE(u, v));
      }
      for(auto edge: EDGE){
          if(edge.x != edge.y){
              add(edge.x, edge.y); add(edge.y, edge.x);
              du[edge.x]++; du[edge.y]++;
          }
          else{
              add(edge.x, edge.y);
              du[edge.x]++;
          }
      }
      //只有O(sqrt(m))个点的度>= K = sqrt(m)
      for(int i = 1; i <= n; i++) if(du[i] >= K){
          memset(c[bitcnt], 0, sizeof (c[bitcnt]));
          conv[i] = bitcnt++;
          for(int j = head[i]; ~j; j = edge[j].next){
              int to = edge[j].to; vec[to].insert(i);
              update(i, w[to], 1);
          }
      }
      
      int q; scanf("%d", &q); while(q--){
          itn op, x, y; scanf("%d", &op);
          if(op == 1){
              x = read(); y = read();
              //w[x] := y;
              //v是所有的相邻大度点
              for(auto v: vec[x]){
                  update(v, w[x], -1);
                  update(v, y, 1);
              }
              w[x] = y;
          }
          else{
              x = read();
              printf("%d\n", mex(x));
          }
      }
  }
  return 0;
159}


网络流

Tue, 14 Jul 2020 15:30:19 +0000

两个定理的证明

https://www.cnblogs.com/cniwoq/p/9245813.html

spfa的一些说明

https://blog.csdn.net/xiazdong/article/details/8193680

dinic

cpp

 1const itn maxn = 1200 + 10;
 2const int maxe = 120000 + 10;
 3const ll inf = 1ll << 60;
 4
 5struct star{int to, next, w;};
 6int head[maxn], top = 0;
 7star edge[maxe << 1];
 8
 9void add(int u, int v, int w){
10    edge[top].to = v;
11    edge[top].next = head[u];
12    edge[top].w = w;
13    head[u] = top++;
14}
15
16int d[maxn], cur[maxn];
17
18ll dfs(int s, int t, ll flow){
19    if(flow == 0 || s == t) return flow;
20    
21    ll res = 0, f;
22    for(int i = cur[s]; ~i; i = edge[i].next){
23        cur[s] = i;
24        if(d[edge[i].to] == d[s] + 1){
25            f = dfs(edge[i].to, t, min(flow, (ll)edge[i].w));
26            edge[i].w -= f; edge[i ^ 1].w += f; res += f; flow -= f;
27            if(flow == 0) break;
28        }
29    }
30    return res;
31}
32
33queue<int> q, q0;
34bool bfs(int s, int t){
35    clr(d, 0);
36    q = q0; q.push(s);
37    cur[s] = head[s]; d[s] = 1;
38    while(!q.empty()){
39        int now = q.front(); q.pop();
40        for(int i = head[now]; ~i; i = edge[i].next) if(!d[edge[i].to] && edge[i].w > 0){
41            cur[edge[i].to] = head[edge[i].to]; d[edge[i].to] = d[now] + 1;
42            if(edge[i].to == t) return true;
43            q.push(edge[i].to);
44        }
45    }
46    return false;
47}
48
49ll dinic(int s, int t){
50    ll ans = 0;
51    while(bfs(s, t)) ans += dfs(s, t, inf);
52    return ans;
53}
54
55
56
57int main(){
58//    Fastin;
59    clr(head, -1);
60    int n, m, s, t; scanf("%d %d %d %d", &n, &m, &s, &t);
61    for(int i = 0, u, v, w; i < m; i++){
62        scanf("%d %d %d", &u, &v, &w);
63        add(u, v, w); add(v, u, 0);
64    }
65    printf("%lld\n", dinic(s, t));
66    return 0;
67}

isap

2020-牛客多校-1

Sun, 12 Jul 2020 19:12:59 +0000

F Periodicity Lemma

叉姐知乎专栏 https://zhuanlan.zhihu.com/which-way-did-the-bicycle-go

另一篇证明 https://zhuanlan.zhihu.com/p/89385360

原文 http://www.karlin.mff.cuni.cz/~holub/soubory/FineWilf.pdf

定理如下：

长为n的字符串S有循环节p、q，且满足p + q - gcd(p, q) <= n，那么有gcd(p, q)也是S的循环节。

已知上述结论后，那么为了比较$s^∞$与$t^∞$的字典序就可以只比较$|s| + |t| - gcd(|s|, |t|)$次。

~~真是高级的结论，证明及其数学思想留坑待补~~

2016-icpc-beijing

Tue, 07 Jul 2020 23:44:24 +0000

二分答案然后跑圆的k次交即可。

因为学习完k次交后精疲力竭就不写完整这道题了。

贴一下用自己的码风写的板子。已更新入模版中。

给出n个圆的平面坐标和半径，能够获得所有圆k次交的面积。

cpp

 1const int manx = 1e2 + 10;
 2const double eps = 1e-8;
 3const double pi = acos(-1);
 4
 5inline int sgn(double x){return x < -eps? -1: x > eps? 1: 0;}
 6inline double sqr(double x){return x * x;}
 7
 8struct CIRCLE{
 9    double x, y, r, angle;
10    int d;
11    CIRCLE(){d = 1; angle = 0;}
12    CIRCLE(double _x, double _y, double _angle = 0, int _d = 0){
13        x = _x; y = _y; angle = _angle; d = _d; r = 0;
14    }
15    bool operator < (const CIRCLE &b)const{
16        return sgn(r - b.r) == -1;
17    }
18};
19
20inline double dis(CIRCLE a, CIRCLE b){return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));}
21inline double cross(CIRCLE a, CIRCLE b, CIRCLE c){
22    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
23}
24
25//有两个交点返回true，以及两个交点的坐标和方位角，p1按照顺时针，p2按照逆时针
26bool cir_inter_cir(CIRCLE a, CIRCLE b, CIRCLE &p1, CIRCLE &p2){
27    double d = dis(a, b);
28    if(sgn(d - a.r - b.r) >= 0 || sgn(abs(b.r - a.r) - d) >= 0) return false;
29    double cosa = (sqr(a.r) + sqr(d) - sqr(b.r)) / (2 * a.r * d);
30    double sina = sqrt(max(0., 1. - sqr(cosa)));
31    //旋转矩阵 [cosa, -sina; sina, cosa]
32    p1 = p2 = a;
33    p1.x += a.r / d * ((b.x - a.x) * cosa + (b.y - a.y) * -sina);
34    p1.y += a.r / d * ((b.x - a.x) * sina + (b.y - a.y) * cosa);
35    p2.x += a.r / d * ((b.x - a.x) * cosa + (b.y - a.y) * sina);
36    p2.y += a.r / d * ((b.x - a.x) * -sina + (b.y - a.y) * cosa);
37    return true;
38}
39
40bool cmp(const CIRCLE &a, const CIRCLE &b){
41    if(sgn(a.angle - b.angle)) return sgn(a.angle - b.angle) == -1;
42    else return a.d > b.d;
43}
44
45double cal(CIRCLE a, CIRCLE p1, CIRCLE p2){
46    double ans = sqr(a.r) * (p2.angle - p1.angle) - cross(a, p1, p2) + cross(CIRCLE(0, 0), p1, p2);
47    return ans / 2;
48}
49
50CIRCLE dot[maxn << 1];
51double area[maxn];
52void cirunion(CIRCLE cir[], int n){
53    sort(cir, cir + n);
54    //记录每个圆被完全覆盖的次数，初始值显然为1
55    for(int i = 0; i < n; i++) for(int j = i + 1; j < n; j++)
56        if(sgn(dis(cir[i], cir[j]) + cir[i].r - cir[j].r) <= 0) cir[i].d++;
57    CIRCLE p1, p2;
58    for(int i = 0; i < n; i++){
59        //针对每一个圆考虑它与所有其他圆的交
60        int cnt = 0, top = 0;
61        for(int j = 0; j < n; j++){
62            if(i == j) continue;
63            if(!cir_inter_cir(cir[i], cir[j], p1, p2)) continue;
64            p1.angle = atan2(p1.y - cir[i].y, p1.x - cir[i].x);
65            p2.angle = atan2(p2.y - cir[i].y, p2.x - cir[i].x);
66            p1.d = -1; p2.d = 1;
67            dot[top++] = p1; dot[top++] = p2;
68            if(sgn(p2.angle - p1.angle) == 1) cnt++;
69        }
70        
71        //加入起点终点位置
72        dot[top++] = CIRCLE(cir[i].x - cir[i].r, cir[i].y, -pi, -2);
73        dot[top++] = CIRCLE(cir[i].x - cir[i].r, cir[i].y, pi, 2);
74        sort(dot, dot + top, cmp);
75        int now = cir[i].d + cnt;
76        for(int j = 1; j < top; j++){
77            area[now] += cal(cir[i], dot[j - 1], dot[j]);
78            now += dot[j].d;
79        }
80    }
81}
82
83CIRCLE cir[maxn];
84int main(){
85//    Fastin;
86    int t; scanf("%d", &t); while(t--){
87        clr(area, 0);
88        int n; scanf("%d", &n);
89        for(int i = 0; i < n; i++) scanf("%lf %lf %lf", &cir[i].x, &cir[i].y, &cir[i].r);
90        cirunion(cir, n);
91        for(int i = 1; i <= n; i++) printf("%.5f\n", area[i]);
92    }
93    return 0;
94}

~~因为网上基本没有讲解只有代码..oi-wiki甚至好像都没有收录这个算法，所以我学了好久才…~~

2016-icpc-qingdao

Tue, 30 Jun 2020 16:00:03 +0000

参考说明：

added saltyfish/2016 ACM/ICPC Asia Regional Qingdao Onsite.page

Fibnacci

D 概率

cpp

 1double qp(double a, int p){
 2    double ans = 1;
 3    while(p){
 4        if(p & 1) ans *= a;
 5        a *= a; p >>= 1;
 6    }
 7    return ans;
 8}
 9
10int n;
11int num[20];
12double p[20], ans[20];
13
14//除了x硬币其余硬币活不到第k轮的概率
15double sove(int x, int k){
16    double ans = 1;
17    for(int i = 0; i < n; i++){
18        if(i == x) continue;
19        ans *= qp((1 - qp(p[i], k)), num[i]);
20    }
21    return ans;
22}
23
24int main(){
25//    Fastin;
26    int t; scanf("%d", &t); while(t--){
27        scanf("%d", &n);
28        fro(int i = 0; i < n; i++){
29            scanf("%d %lf", num + i, p + i);
30            ans[i] = 0;
31        }
32        if(n == 1) printf("1.000000\n");
33        else{
34            //实验100轮
35            for(int i = 1; i <= 100; i++) for(int x = 0; x < n; x++){
36                ans[x] += (sove(x, i) - sove(x, i - 1)) * (1 - qp((1 - qp(p[x], i)), num[x]));
37            }
38            for(int i = 0; i < n; i++){
39                printf("%.6f", ans[i]);
40                if(i != n - 1) printf(" ");
41                else printf("\n");
42            }
43        }
44    }
45    return 0;
46}

考虑所有三元组，图是若干个团之并的充要条件是不存在某个三元组中有两条边（实际上就是要满足传递性），于是任取一个有两条边的三元组，枚举加上剩下的边或者删除现有两条边之一，修改一条边之后会有$O(n)$个三元组受影响，暴力修改这些三元组，同时用一个队列+时间戳维护当前有两条边的三元组，搜$10$步即可，复杂度是$O(n^3+n3^{10})$

2017-ICPC-jakarta

Sat, 27 Jun 2020 22:51:59 +0000

B 动态维护两个序列之间的最小差值

尝试将图二分染色。如果不能二分染色，那么两人无论初始处于什么位置一定都有某种策略走到同一个节点；如果能够二分染色，题目则等价转化求$min{|u - v|}, u∈A, v∈B$，并且支持在线修改，这种情况是我们要着重处理的问题。

为此，利用multiset作为一个有序容器来实现这个功能。

CF-1373E

Sat, 27 Jun 2020 18:09:30 +0000

其实是一道比较简单的暴力构造题（？）

但是因为没有往这方面去考虑所以就…

~~正如之前看到过第一个造原子弹的国家才是真正厉害的因为这是开辟一条从0到1的道路后面的效仿者已知结果可行再去效仿就容易很多~~

这道题中最麻烦的地方在于如果产生进位会如何影响结果。

如果一个数末尾有连续k个9，那么对其加1后其数码之和会变化+1 - 9k。

CF-#651-div2

Sun, 21 Jun 2020 21:38:35 +0000

值得注意的题：F 树上二分 & 交互

显然是$floor(n/2)$

为什么一定存在呢？分奇偶项后就容易说明了。

最开始读错题了，以为必须要奇素因子…不需要的话只需要分类考虑一下奇数因子的个数和2的个数即可。

为什么一定存在呢？分奇偶项后就容易说明了。

最开始读错题了，以为必须要奇素因子…不需要的话只需要分类考虑一下奇数因子的个数和2的个数即可。

0619-weekly-test-B

Fri, 19 Jun 2020 21:38:03 +0000

题目要求我们写一个指定语法的程序，要求这个程序能够输出指定fibnacci数列中的某一项，询问至多不超过30项。

这道题目还是蛮新颖的，虽然不算很难，但是因为坑到我了…所以还是写篇简短的博客记录一番。

这道题目可行的程序很多~~以至于WA了之后不知道怎么改~~，我的算法是初始化[n, 0, 1]之后循环判断当前n是否为1，不是的话将[n, y, x]变成[n - 1, x, x + y]，然后再次jump到判断语句处。主要分成三个模块：判断是否为1，对n减一，变换[y, x]成为[x, x + y]。结合操作随意构造一番即可。

对拍程序

Thu, 18 Jun 2020 21:55:46 +0000

因为今天打比赛队友对拍出了一个错误结果，所以我也趁机自己写了一番这个一直没有实现的技术，用起来还是很舒爽的。

cpp

 1#include <iostream>
 2
 3int main(int argc, const char * argv[]) {
  system("g++ ~/Desktop/data/data/main.cpp -std=c++11 -o data.out");
  system("g++ ~/Desktop/T/T/main.cpp -std=c++11 -o T.out");
  system("g++ ~/Desktop/ttt/ttt/main.cpp -std=c++11 -o ttt.out");
  
  int times = -1;
  scanf("%d", &times);
  int cnt = 0;
  while(times != 0){
      times--;
      system("./data.out >~/Desktop/in.txt");
      system("./T.out < ~/Desktop/in.txt > ~/Desktop/out.txt");
      system("./ttt.out < ~/Desktop/in.txt > ~/Desktop/ans.txt");
      if(system("diff ~/Desktop/out.txt ~/Desktop/ans.txt")){
          puts("Differences occur!");
          break;
      }
      printf("No.%d's OK.\n", cnt++);
  }
  return 0;
23}

template

Wed, 17 Jun 2020 16:34:39 +0000

1 字符串

trie树

实现一：数组实现的按键查找

cpp

 1const int maxn = 2e5 + 10;
 2const int maxsize = 26;
 3struct TRIE{
  int ch[maxn][maxsize];
  int flag[maxn];
  int top = 1;
 7
  //按照实际条件进行修改
  inline int getid(char c){return c - 'a';}
10
  //插入长度为n的字符串s[0,..n - 1]
  void insert(char s[maxn], int n){
      int u = 0;
      for(int i = 0; i < n; i++){
          int id = getid(s[i]);
          if(!ch[u][id]) ch[u][id] = top++;
          u = ch[u][id];
      }
      flag[u] = 1;
  }
21
  bool query(char s[maxn], int n){
      int u = 0;
      for(int i = 0; i < n; i++){
          int id = getid(s[i]);
          if(!ch[u][id]) return false;
          u = ch[u][id];
      }
      if(flag[u]) return true; return false;
  }
31};

实现二：数组实现的按边查找（左儿子右兄弟优化）

利用可持久化01Trie解决区间异或一类问题

Tue, 16 Jun 2020 22:16:25 +0000

为了补校赛网络的I题，就去看了异或粽子，然后就看到了Trie以及可持久化01Trie，进而就有了这篇博客qaq

借助这几道题学习一番可持久化01Trie的有关知识

参考博客： 可持久化01Trie + 异或粽子（精心)

P4735 最大异或和

题目要求区间中某个位置p∈[L, R]使得a[p] ^ a[p + 1]^ ... ^ a[n] ^ x最大，其中p, L, R给定，允许在该序列末尾动态添加数字。首先根据异或的性质等价转化要求的表达式：``a[p] ^ a[p + 1]^ … ^ a[n] ^ x = x ^ sum ^ a[1] ^ a[2] ^ … ^ a[p - 1] `，其中sum是整个序列的异或值；因而在某个给定的状态下，我们只需要找位置p-1使得其前缀异或值和x^sum异或值最大即可。为了完成动态修改、查询的工作，我们使用可持久化01Trie，其思想与主席树类似（~~尽管我还没学但是不妨碍我学会01Trie~~)。

2017_CCPC_HARBIN

Tue, 16 Jun 2020 19:40:08 +0000

新博客的第一篇文章，打算吸取一下之前CSDN写完博客找不到题的教训：对于套题的补题应该设置一些比较明显的目录以待今后查阅，每个题目的题目以及知识点都予以简单的描述。

2017中国大学生程序设计竞赛-哈尔滨站

这好像是一场比较难(~~但是队友很顶~~)的训练赛，然而我又一次死在了计算几何上，并且成为爆交狂魔…qaq