之前的博客基于 Jekyll + Hux Blog 主题，用了快一年，总觉得不太顺手。Jekyll 是 Ruby 生态，本地构建慢，主题样式偏重（大图背景、多栏布局），对我这种只想简洁写文章的人来说有点臃肿。

于是决定迁移。目标是：

• 🚀 更快的构建速度
• 🎨 极简的页面风格 —— 无背景图、干净利落
• 🔧 少折腾 —— 配置简单，开箱即用
• 📝 保留所有文章和资源

最终选择了 Hugo + PaperMod 主题。

为什么选 Hugo？

Hugo 最大的优势就是快——单二进制文件，没有任何依赖，构建 55 篇文章只要 250ms。PaperMod 主题默认就是白色极简风格，没有大图背景，几乎没有需要改动的地方。

迁移做了什么

1. 文章转换（55 篇）

原来的 Jekyll 文章格式：

1
2
3
4
5
6
7
8
9

---
layout: post
title: "Introduction to Linear Programing"
date: 2025-09-14 23:54:39 +0800
author: "farmer3-c"
header-img: "img/post-bg-2015.jpg"
mathjax: true
tags: []
---

转换为 Hugo 格式：

1
2
3
4
5
6
7

---
title: "Introduction to Linear Programing"
date: "2025-09-14T23:54:39+08:00"
author: "farmer3-c"
mathjax: true
tags: []
---

主要变化：删掉了 layout、header-img 等 Jekyll 特有字段，日期改为 ISO 8601 格式。

2. 资源迁移

• img/ → static/img/（路径不变，文章中的图片引用不受影响）
• pdf/ → static/pdf/
• 删除了所有背景大图（*-bg-*.jpg）

3. 功能集成

新博客使用指南

环境准备

1
2
3
4
5
6

# 安装 Hugo（Windows）
# 从 https://github.com/gohugoio/hugo/releases 下载 hugo_extended 版本
# 解压后添加到 PATH 即可

# 验证安装
hugo version

本地预览

1
2
3
4
5

# 在博客根目录启动服务器
hugo server

# 浏览器访问 http://localhost:1313/
# 修改文件后自动刷新

新建文章

1

hugo new content posts/my-new-post.md

然后在 content/posts/my-new-post.md 中编辑：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

---
title: "文章标题"
description: "文章摘要"
date: "2026-06-28T23:00:00+08:00"
author: "farmer3-c"
tags:
  - Tag1
  - Tag2
mathjax: true  # 如果用到 LaTeX 则启用
draft: false
---

添加图片

将图片放到 static/img/ 目录下，在文章中引用：

1

![描述](/img/your-image.png)

添加 PDF

将 PDF 放到 static/pdf/ 目录下：

1

[下载文档](/pdf/filename.pdf)

部署

推送到 GitHub 即可自动构建部署：

1
2
3

git add -A
git commit -m "更新"
git push origin main

GitHub Actions 会自动运行 Hugo 构建，将 public/ 目录部署到 GitHub Pages。

文件结构

farmer3-c.github.io/
├── hugo.toml              # 主配置文件
├── content/
│   ├── posts/             # 所有文章
│   ├── about/             # 关于页面
│   └── search.md          # 搜索页
├── static/
│   ├── img/               # 图片资源
│   ├── pdf/               # PDF 文件
│   └── CNAME              # 自定义域名
├── layouts/
│   └── partials/
│       ├── comments.html  # Utterances 评论
│       └── extend_head.html  # MathJax 3
├── assets/
│   └── css/extended/
│       └── custom.css     # 自定义样式
└── .github/workflows/
    └── hugo.yml           # 自动部署

总结

这次迁移大概花了一晚上的时间，最耗时的是 55 篇文章的格式转换和内部链接检查。迁移之后，博客构建速度从秒级降到了毫秒级，主题干净了很多，写文章的体验也好了不少。

希望这篇记录对想从 Jekyll 迁移到 Hugo 的朋友有帮助 😄

之前想在Windows上使用Linux系统，wsl很方便（为Windows用户提供了Linux环境，不需要装系统什么的）。但是不知道为什么，启动wsl的时间越来越长，从一开始的十几秒到后来的几分钟，实在让我不能忍受。我原来使用的是WSL 2，发现WSL 1 不依赖 Hyper-V 虚拟化，它直接共享 Windows 主机的 IP，启动会很快，所以试试转为 WSL 1。

过程

在 PowerShell 中逐条执行以下命令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 1. 备份当前环境 
wsl --export Ubuntu-22.04 D:\wsl-backup.tar

# 2. 转换为 WSL 1
wsl --set-version Ubuntu-22.04 1

# 3. 彻底重启 WSL
wsl --shutdown

# 4. 测试启动速度
Measure-Command { wsl -d Ubuntu-22.04 --exec true }

# 5. 测试网络
wsl -d Ubuntu-22.04
# 进入 WSL 后，运行：
ping baidu.com

结果：

启动很快，网络也没有问题，暂时没发现其他问题。

下面是完整操作（Windows/Mac/Linux 通用）：

一、准备工作

1. 安装 Git：

   终端输入：

   1	git --version

   能显示版本就说明已安装；没有就先装 Git。

2. 在 GitHub 建同名空仓库

   • 右上角点 + → New repository

   • Repository name：和你本地文件夹同名

   • 不要勾选：Add a README file、.gitignore、License

   • 点 Create repository

   • 复制仓库地址（HTTPS 或 SSH），例如：

     1	https://github.com/你的用户名/仓库名.git

二、本地操作

打开终端（Git Bash / Terminal / PowerShell），进入你要上传的本地目录根目录：

1

cd /path/to/你的本地文件夹   # Windows 示例：cd D:\my-project

1. 初始化为 Git 仓库

1

git init

2. 添加所有文件到暂存区

1

git add .

（想忽略某些文件，新建 .gitignore 写规则，比如 node_modules/、*.log）

3. 提交到本地仓库

1

git commit -m "Initial commit: 上传本地全部文件"

4. 关联远程 GitHub 仓库

1

git remote add origin https://github.com/你的用户名/仓库名.git

如果提示 remote origin already exists，先删旧关联：

1

git remote remove origin

再重新执行上面命令。

5. 重命名分支为 main（和 GitHub 默认一致）

1

git branch -M main

6. 推送到 GitHub

1

git push -u origin main

• -u：以后直接 git push 即可，不用每次写 origin main
• 输入 GitHub 账号密码（或用个人访问令牌），完成。

三、常见报错解决

1. fatal: remote origin already exists

   → git remote remove origin 后重新关联。

2. error: src refspec main does not match any

   → 没 add 或 commit 成功，重新执行：

   1 2	git add . git commit -m "Initial commit"

3. 合并冲突（远程有 README 等）

   → 必须保证远程是空仓库；如果已有内容，用：

   1	git pull origin main --allow-unrelated-histories

   解决冲突后再 push。

实现一个能处理 main 函数和 return 语句的编译器.编译器可以将如下的 SysY 程序:

int main() {
  // 注释也应该被删掉哦
  return 0;
}

编译为对应的 Koopa IR:

fun @main(): i32 {
%entry:
  ret 0
}

实现

Lv1.2. 词法/语法分析初见

我使用项目提供的c++模板，直接执行：

make
build/compiler -koopa hello.c -o hello.koopa

输出：

int main() { return 0; }

这是因为默认的模板使用string存放ast，所以输出的ast也是string形式：

CompUnit
  : FuncDef {
    ast = unique_ptr<string>($1);
  }
  ;

Lv1.3. 解析 main 函数

这里设计一个ast用于输出程序的语法结构，教程写的已经很详细了：写一个头文件来定义AST,对于头文件重复声明的问题，加上#pragma once就可以解决。

我是这样定义基类和子类进行构造的：

// 所有 AST 的基类
class BaseAST {
 public:
  virtual ~BaseAST() = default;
  virtual void Dump() const = 0;
};

// CompUnit 是 BaseAST
class CompUnitAST : public BaseAST {
 public:
  // 用智能指针管理对象
  std::unique_ptr<BaseAST> func_def;

    void Dump() const override {
    std::cout << "CompUnitAST { ";
    func_def->Dump();
    std::cout << " }";
  }
};
……

同时，修改参数类型的相关声明：比如%parse-param { std::unique_ptr<string> &ast } 改为%parse-param { std::unique_ptr<BaseAST> &ast }

make之后就会输出CompUnitAST { FuncDefAST { FuncTypeAST { int }, main, BlockAST { StmtAST { 0 } } } } 。

Lv1.4. IR 生成

我采用定义 AST 一样定义表示 Koopa IR 的数据结构, 然后遍历 AST 输出这种结构, 再遍历这种结构输出字符串。

类似的，写一个KoopaIR头文件，定义它的结构：

// Value 是所有指令和常量的基类
class Value {
 public:
  virtual ~Value() = default;
  virtual void Dump() const = 0;
};

// 整数常量
class Integer : public Value {
 public:
  int value;
  
  Integer(int v) : value(v) {}
  
  void Dump() const override {
    std::cout << value;
  }
};

接着完成GenerateIR的工作，完成遍历 AST 生成 IR，由于只需要识别main函数就可以了，复杂一些的递归之类的暂时不需要写。

main.cpp
  │
  ├─ yyparse(ast)          // 调用 Bison/Flex 解析源码 → 得到 AST
  │
  ├─ GenerateIR(*ast)      // ← 遍历 AST，生成 Koopa IR (Program)
  │     └─ IRGenerator.cpp
  │          ├─ dynamic_cast<CompUnitAST*> 取出 func_def
  │          ├─ dynamic_cast<FuncDefAST*>  取出 ident + block
  │          ├─ dynamic_cast<BlockAST*>    取出 stmt
  │          ├─ dynamic_cast<StmtAST*>     取出 num
  │          └─ 构建 Return(Integer(num)) → BasicBlock → Function → Program
  │
  └─ program->Dump()       // 以文本格式输出 Koopa IR

Lv1.5. 测试

有一个小问题，模板给出的sysy.l没有给出注释块的定义，需要我们自己加上BlockComment "/*"(.|\n)*?"*/",否则测试的时候会有一个测试点不过。

测试结果：

C盘越来越满，D盘和E盘还有许多空间，磁盘合并理所当然的成为了一个缓解C盘压力的解决方案。

想法

我的想法是将D盘的文件都挪到E盘，然后腾出D盘的空间来分配到C盘和E盘。考虑到我习惯使用D盘存放应用，所以我打算之后将E盘的盘符改成D。

处于方便和迅捷考虑，我使用robocopy "D:\" "E:\D盘备份" /E /J /MT:8 /R:3 /W:1复制D盘文件到E盘的一个文件夹，效果还不错。于是在完成修改后我同样使用robocopy D:\D盘备份 D:\ /E /MIR来将配置带到新的D盘，殊不知这会带来怎么样的灾难😭

过程

我使用MiniTool Partition Wizard进行磁盘操作。由于原来D盘删除后的内存与C盘之间存在恢复分区，C盘只能合并它右侧的空间，所以要move恢复分区，这就为C盘扩容了。

然后是将剩余空间合并到E盘，结果因为BitLocker而合并不了，解密之后顺利合并。

最后，灾难性的一幕发生了，使用robocopy D:\D盘备份 D:\ /E /MIR后，修改后D盘空了。

可能的原因是：带 /MIR 的 robocopy 命令在执行时，先清空了 D 盘根目录，再尝试复制备份文件，但中途因为 $RECYCLE.BIN 报错中断，导致备份文件也被系统误删了。

数据恢复工具需要的时间太长了，被删除的数据也没有很重要的，我就先配置了日常要用的工具草草了结了，剩下的日后再说。

说明：本篇内容译自 Santa Clara University COEN 259 编译原理课程讲义，用于学习 Flex 和 Bison 编译器工具。 本篇内容为个人学习，不构成任何商业用途。

Flex

Flex 是一个用于词法分析的扫描器生成工具，它基于有限状态机 (FSM)。输入是一组正则表达式，输出是根据输入规则实现扫描器的代码。

为了实现计算器的一个扫描器，我们可以将文件 “cal1.l” 编写如下：

/* this is only for scanner, not link with parser yet */ 
%{ 
int lineNum = 0; 
%} 
 
%% 
 
"(" { printf("(\n"); } 
")" { printf(")\n"); } 
"+" { printf("+\n"); } 
"*" { printf("*\n"); } 
\n { lineNum++; } 
[ \t]+ { } 
[0-9]+ { printf("%s\n", yytext); } 
 
%% 
 
int yywrap() { 
 return 1; 
} 
 
int main () { 
 yylex(); 
 return 0; 
} 

这是用于构建扫描器的 Makefile：

p1: lex.yy.o 
 gcc -g -o p1 lex.yy.o 
 
lex.yy.o: cal1.l 
 flex cal1.l; gcc -g -c lex.yy.c 
 
clean: 
 rm -f p1 *.o lex.yy.c

注意：对于更复杂的 flex 输入文件，你可能会收到类似的错误信息

parse tree too big, try %a num (or %e num)" 

然后你需要定义 %e <num>。你应该把它放在宏和 %start 符号之间。其他选项有 %a、%o、%n、%p 等。

Bison

Bison 是一个用于语法分析的 LALR(1) 解析器生成工具，它基于下推自动机 (PDA)。输入是一组上下文无关文法 (CFG) 规则，输出是根据输入规则实现解析器的代码。

要实现计算器的一个解析器，我们可以按如下方式编写文件“cal.y”:

%{ 
#include <stdio.h> 
#include <ctype.h> 
int lineNum = 1; 
void yyerror(char *ps, ...) {  /* need this to avoid 
link problem */ 
 printf("%s\n", ps); 
} 
%} 
 
%union { 
 int d; 
} 
// need to choose token type from union above 
%token <d> NUMBER 
%token '(' ')' 
%left '+' 
%left '*' 
%type <d> exp factor term 
 
%start cal 
 
%% 
 
cal 
  : exp 
 { printf("The result is %d\n", $1); } 
  ; 
 
exp 
  : exp '+' factor 
 { $$ = $1 + $3; } 
  | factor 
 { $$ = $1; } 
  ; 
 
factor
 : factor '*' term 
 { $$ = $1 * $3; } 
  | term 
 { $$ = $1; } 
  ; 
 
term 
  : NUMBER 
 { $$ = $1; } 
  | '(' exp ')' 
 { $$ = $2; } 
  ; 
 
%% 
 
int main() { 
 yyparse(); 
 return 0; 
}

为了整合扫描器和解析器，我们需要修改扫描器输入文件“cal1.l”，并将其保存为“cal.l”，如下所示：

%{ 
#include <stdlib.h> /* for atoi call */ 
#define DEBUG  /* for debuging: print tokens and 
their line numbers */ 
#define NUMBER 258 /* copy this from cal.tab.c */ 
typedef union {  /* copy this from cal.tab.c */ 
 int d; 
} YYSTYPE; 
YYSTYPE yylval; /* for passing value to parser */ 
extern int lineNum; /* line number from cal.tab.c */ 
%} 
 
%% 
 
[ \t]+ {} 
[\n] { lineNum++; } 
"(" { 
#ifdef DEBUG 
  printf("token '(' at line %d\n", lineNum); 
#endif 
  return '('; 
 } 
")" { 
#ifdef DEBUG 
  printf("token ')' at line %d\n", lineNum); 
#endif 
  return ')'; 
 } 
"+" {
#ifdef DEBUG 
  printf("token '+' at line %d\n", lineNum); 
#endif 
  return '+'; 
 } 
"*" { 
#ifdef DEBUG 
  printf("token '*' at line %d\n", lineNum); 
#endif 
  return '*'; 
 } 
[0-9]+ { 
#ifdef DEBUG 
 printf("token %s at line %d\n", yytext, lineNum); 
#endif 
 yylval.d = atoi(yytext); 
 return NUMBER; 
} 
 
%% 
 
int yywrap() {  /* need this to avoid link problem */ 
 return 1; 
}

这是用于构建扫描器和解析器的 Makefile：

p2: lex.yy.o cal.tab.o 
 gcc -o p2 lex.yy.o cal.tab.o 
 
lex.yy.o: cal.l 
 flex cal.l; gcc -c lex.yy.c 
 
cal.tab.o: cal.y 
 bison -d cal.y; gcc -c cal.tab.c 
 
clean: 
 rm -f p2 cal.output *.o cal.tab.c lex.yy.c 

有一些调试 Bison 的技巧。

1. 使用 -v 选项运行 Bison，然后会生成一个名为 cal.output 的文件。它包含所有的冲突和/或永远不会被归约的规则，以及 Bison 生成的所有状态。
2. 获取 Bison 的调试信息：首先，在编译 cal.tab.c 时添加 -DYYDEBUG；其次，设置环境变量 YYDEBUG=1。然后它会打印大量的调试信息，例如如何进行移入或归约。

原文

最近对博客进行了多次优化，遇到了各种问题，现在总结一下遇到的问题及解决方案，供大家参考。

1. Service Worker 自动刷新问题

问题描述

博客添加了 Service Worker 后，每次检测到更新都会显示 “Content updated. REFRESH” 按钮，需要手动点击刷新。

解决方案

修改 js/sw-registration.js，移除手动刷新提示，直接使用 location.reload()。

1
2
3
4
5

if(data.command == "UPDATE_FOUND"){
  console.log("UPDATE_FOUND_BY_SW", data);
  // 自动刷新页面，无需手动点击
  location.reload();
}

后续问题

启用自动刷新后，网站出现了无限刷新循环的问题，用户体验极差。

最终解决方案

移除 Service Worker 的自动刷新机制，改用 Stale-While-Revalidate 缓存策略：

• 优先显示缓存内容
• 后台更新缓存
• 用户下次访问时自然看到新内容

2. 导航栏显示文章标题问题

问题描述

导航栏突然显示了文章标题 “编译实践Lv1. main 函数”，而不是正常的页面链接。

根本原因

之前误将一篇博客文章放到了 css/ 文件夹，Jekyll 将其当作页面处理，导致导航栏循环显示所有有 title 的页面。

解决方案

彻底解决方案： 硬编码导航栏，只显示固定页面。

修改 _includes/nav.html：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<ul class="nav navbar-nav navbar-right">
  <li>
    <a href="{{ site.baseurl }}/">Home</a>
  </li>
  <li>
    <a href="{{ site.baseurl }}/about/">About</a>
  </li>
  <li>
    <a href="{{ site.baseurl }}/archive/">Archive</a>
  </li>
  <li class="search-icon">
    <a href="javascript:void(0)">
      <i class="fa fa-search"></i>
    </a>
  </li>
</ul>

同时从 git 历史中彻底移除误放的文章。

3. About 和 Archive 页面 404 问题

问题描述

点击导航栏的 About 和 Archive，跳转到 /about.html 和 /archive.html，显示 404 错误。

原因

博客使用了 permalink: pretty 配置，正确的 URL 应该是 /about/ 和 /archive/（带斜杠），而不是 .html 结尾。

解决方案

修改导航栏链接格式：

1
2
3
4
5
6
7

<!-- 修改前 -->
<a href="{{ site.baseurl }}/about.html">About</a>
<a href="{{ site.baseurl }}/archive.html">Archive</a>

<!-- 修改后 -->
<a href="{{ site.baseurl }}/about/">About</a>
<a href="{{ site.baseurl }}/archive/">Archive</a>

4. GitHub Pages 构建队列卡住问题

问题描述

推送代码后，GitHub Actions 一直显示 “Queued” 状态，超过 10 分钟甚至更久都没有构建。

原因分析

这是 GitHub 服务本身的问题，不是代码问题。根据 GitHub Status 页面显示，GitHub Actions 服务正在经历事故（Incident）。

解决方案

1. 等待 GitHub 修复

   • 通常需要 30 分钟到几小时
   • 关注 https://www.githubstatus.com/ 获取最新状态

2. 检查 GitHub 服务状态

   • GitHub Status: https://www.githubstatus.com/
   • Twitter: @githubstatus
   • Downdetector: downdetector.com/status/github

3. 本地验证代码正常

   1	bundle exec jekyll build

   如果本地构建成功，说明代码没问题，只是 GitHub 服务问题。

预防措施

• 推送代码前先在本地预览
• 避免在 GitHub 服务不稳定时推送重要更新

5. 新文章推送后不显示问题

问题描述

新写的文章 git push 之后在博客网站没有显示。

常见原因

1. 文件名格式问题

   • 要求：YYYY-MM-DD-title.md
   • 避免在文件名末尾使用特殊字符

2. Front Matter 格式问题

   1 2 3 4 5 6

   --- layout: post title: "文章标题" date: 2026-03-06 tags: [Tag1, Tag2] # 标签用逗号分隔，不要有空格 ---

3. 标签格式问题

   1 2 3 4 5 6 7

   # 错误：包含空格的标签 tags: [Algorithm programming problem] # 正确：逗号分隔或加引号 tags: [Algorithm, programming, problem] # 或 tags: ["Algorithm programming problem"]

解决方案

• 确保文件名格式正确
• 检查 front matter 格式
• 修复后重新提交推送

6. LaTeX 数学公式渲染失败问题

问题描述

博客中的 LaTeX 代码显示为纯文本 [Math Processing Error]，无法正常渲染。

解决方案

更新 MathJax 配置到稳定版本。

修改 _includes/mathjax_support.html：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<script type="text/x-mathjax-config">
  MathJax.Hub.Config({
    tex2jax: {
      inlineMath: [ ['$','$'], ['\\(','\\)'] ],
      displayMath: [ ['$$','$$'], ['\\[','\\]'] ],
      processEscapes: true
    },
    TeX: {
      equationNumbers: { autoNumber: "AMS" },
      extensions: ["AMSmath.js","AMSsymbols.js"]
    },
    "HTML-CSS": {
      scale: 100
    }
  });
</script>
<script src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS_HTML"></script>

使用方法

确保文章头部开启了 mathjax：

1
2
3

---
mathjax: true
---

支持的语法：

7. 添加相关文章侧边栏功能

功能描述

在文章页面左侧显示同标签的其他文章列表，方便读者浏览相关内容。

解决方案

1. 创建 _includes/related-posts.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

{% if page.tags.size > 0 %}
<div class="related-posts">
    <hr class="hidden-sm hidden-xs" style="margin: 0 0 20px 0;">
    <h5 style="color: #333; margin-bottom: 15px; font-size: 14px; font-weight: bold;">相关文章</h5>
    <ul class="related-posts-list">
        {% assign current_url = page.url %}
        {% assign tag_posts = "" | split: "" %}

        {% for tag in page.tags %}
            {% for post in site.tags[tag] %}
                {% unless post.url == current_url %}
                    {% unless tag_posts contains post %}
                        {% assign tag_posts = tag_posts | push: post %}
                    {% endunless %}
                {% endunless %}
            {% endfor %}
        {% endfor %}

        {% for post in tag_posts limit: 10 %}
        <li>
            <a href="{{ post.url | prepend: site.baseurl }}">
                {{ post.title | truncate: 28 }}
            </a>
        </li>
        {% endfor %}
    </ul>
</div>
{% endif %}

2. 修改 _layouts/post.html，在左侧添加：

1
2
3
4

<!-- Left Sidebar - Related Posts -->
<div class="col-lg-2 visible-lg-block sidebar-container">
    {% include related-posts.html %}
</div>

总结

经验教训

1. 本地预览很重要 - 推送前先在本地测试
2. GitHub 服务也会出问题 - 遇到问题先检查服务状态
3. 文件名和格式要规范 - 遵循 Jekyll 的命名规则
4. 做好备份 - 重要修改前先 commit

本文持续更新中…

今天遇到了一个问题，c++编程解决问题时不能正确输出，于是我想使用断点调试来找出问题所在。此前很少使用断点调试，对于调试的几个按钮仅仅认为向下的箭头是向下运行一步、向上的箭头是回退一步、方框是退出调试。

于是：出现 （1）

本应长度为3的数组b却是std::vector of length -1198221809, capacity 2069355498。

继续点击向下的箭头；结果在几个头文件中来回转跳 （2）

回退到（1）的状态，再点击step over符号，数组b的长度恢复正常： （3）

不知道其中原因，我查了下断点用法。

断点使用

单步调试： 进入下一行代码的方法，以便逐行跟踪其执行过程。意思是说要把最基础的编译文件显示出来，单步跳过封装了执行单步调试的所有过程，可以一直按 F11 达到 F10 所完成的任务。

之前以为按f11是在几个头文件中来回转跳，其实不是。

参考

• 使用 Visual Studio Code 调试代码

给你一个大小为 4 的整数数组 a 和一个大小 至少为 4 的整数数组 b。

你需要从数组 b 中选择四个下标 i0, i1, i2, 和 i3，并满足 i0 < i1 < i2 < i3。你的得分将是 a[0] * b[i0] + a[1] * b[i1] + a[2] * b[i2] + a[3] * b[i3] 的值。

返回你能够获得的 最大 得分。

提示：

• $a.length == 4$
• $4 <= b.length <= 10^5$
• $-10^5 <= a[i], b[i] <= 10^5$

思路

用dp来做，从后往前选取a[i]、b[j]相乘，考虑2种状态：

选当前a[i]、b[j]相乘，继续考虑a[i-1]、b[j-1]

不选选当前a[i]、b[j]相乘，继续考虑a[i]、b[j-1]

状态转换：

dfs(i,j)=max(dfs(i-1,j-1)+a[i]*b[j],dfs(i,j-1))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution {
public:
    long long maxScore(vector<int>& a, vector<int>& b) {
        int n=b.size();
        vector<array<long long,4>>memo(n);
        for(auto&row:memo){
            ranges::fill(row,LLONG_MIN);
        }
        auto dfs=[&](auto&&dfs,int i,int j)->long long{
            if(j<0)return 0;
            if(i<0){
                return LLONG_MIN/2;

            }
            auto &res=memo[i][j];
            if(res==LLONG_MIN){
                res=max(dfs(dfs,i-1,j),dfs(dfs,i-1,j-1)+(long long)a[j]*b[i]);
            }
            return res;
        };
        return dfs(dfs,n-1,3);
    }
};

参考

• 灵茶山艾府

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

提示：

• 1 <= strs.length <= 600
• 1 <= strs[i].length <= 100
• strs[i] 仅由 '0' 和 '1' 组成
• 1 <= m, n <= 100

思路

首先，这是一个二维0-1背包问题，可以使用三维数组解决。

f[i][j][k]:i代表0~i的选取结果,j代表不超过j个零,k同理。

f[i][j][k]=max(dp[i−1][j][k],dp[i−1][j−当前字符串使用0的个数][k−当前字符串使用1的个数]+1)

dp[i−1][j][k] 不选择当前考虑的字符串i

dp[i−1][j−当前字符串使用0的个数][k−当前字符串使用1的个数]+1 选择当前考虑的字符串​

初始化：为了避免分类讨论，通常多设置一行。这里可以认为，第 0 个字符串是空串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
         vector<vector<vector<int>>> dp(len + 1, vector<vector<int>>(m + 1, vector<int>(n + 1, 0)));
        for (int i = 1; i <= len; i++) {
            int x1 = cnum(strs[i - 1]);
            int x0 = strs[i - 1].size() - x1;
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j >= x0 && k >= x1) {
                        dp[i][j][k] =
                            max(dp[i - 1][j][k], dp[i - 1][j - x0][k - x1] + 1);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
    int cnum(string s) {
        int cnt = 0;
        for (auto c : s) {
            if (c == '1')
                cnt++;
        }
        return cnt;
    }
};

参考

• liweiwei1419

一个 「开心字符串」定义为：

• 仅包含小写字母 ['a', 'b', 'c'].
• 对所有在 1 到 s.length - 1 之间的 i ，满足 s[i] != s[i + 1] （字符串的下标从 1 开始）。

比方说，字符串 “abc”，“ac”，“b” 和 “abcbabcbcb” 都是开心字符串，但是 “aa”，“baa” 和 “ababbc” 都不是开心字符串。

给你两个整数 n 和 k ，你需要将长度为 n 的所有开心字符串按字典序排序。

请你返回排序后的第 k 个开心字符串，如果长度为 n 的开心字符串少于 k 个，那么请你返回 空字符串 。

提示：

• 1 <= n <= 10
• 1 <= k <= 100

思路

首先，长度为 n 的开心字符串个数为(1<<(n-1))*3，若小于k，则返回空字符串 。

设置一个字符作为已经添加的前一个字符，保证得到开心字符串。

令count_per_choice=1<<(n-i-1)为每添加一个字符所代表的可能性，每次从a到c遍历，若count_per_choice>=k,则取当前字符，跳出循环，否则k-count_per_choice,继续遍历。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Solution {
public:
    string getHappyString(int n, int k) {
        
        int total = 3 * (1 << (n - 1)); 
        if (k > total) return "";
        
        string result;
        char prev = '\0';
        
        for (int i = 0; i < n; ++i) {
      
            int count_per_choice = 1 << (n - i - 1); // 2^(n-i-1)
            
            for (char c = 'a'; c <= 'c'; ++c) {
                if (c == prev) continue; 
                
                if (k <= count_per_choice) {
                    result += c;
                    prev = c;
                    break;
                }
                k -= count_per_choice;
            }
        }
        
        return result;
    }
};

给你 3 个正整数 zero ，one 和 limit 。

一个 二进制数组 arr 如果满足以下条件，那么我们称它是 稳定的 ：

• 0 在 arr 中出现次数 恰好 为 zero 。
• 1 在 arr 中出现次数 恰好 为 one 。
• arr 中每个长度超过 limit 的 子数组 都 同时 包含 0 和 1 。

请你返回 稳定 二进制数组的 总 数目。

由于答案可能很大，将它对 $10^9 + 7$ 取余 后返回。

提示：

• 1 <= zero, one, limit <= 200

思路

首先，这个问题是每个位有两个选择0/1，再加上限制limit,感觉就可以用dp做。

定义：

f[i][j][0] 为使用 i 个 0，j 个 1，且末尾为 0 的稳定数组个数；

f[i][j][1] 为使用 i 个 0，j 个 1，且末尾为 1 的稳定数组个数。

因为limit的限制，末尾连续0/1的数量不能超过它，f[i][j][0]为f[i-limit][j][0]~f[i-1][j][0]之和，f[i][j][1]同理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Solution {
public:
    int f[205][205][2] = {0};
    int numberOfStableArrays(int z, int o, int limit) {
        const int mod = 1e9 + 7;
        for (int i = 0; i <= z; i++) {
            f[i][0][0] = (i <= limit), f[i][0][1] = 0;
        }
        for (int i = 0; i <= o; i++) {
            f[0][i][0] = 0, f[0][i][1] = (i <= limit);
        }
        int sum1[o + 1];
        for (int j = 0; j <= o; j++) {
            sum1[j] = f[0][j][1];
        }
        for (int i = 1; i <= z; i++) {
            for (int j = 1, sum0 = f[i][0][0]; j <= o; j++) {
                f[i][j][0] = sum1[j];
                f[i][j][1] = sum0;

                sum0 = (sum0 + f[i][j][0]) % mod;
                if (j >= limit) {
                    sum0 = (sum0 + mod - f[i][j - limit][0]) % mod;
                }
                sum1[j] = (sum1[j] + f[i][j][1]) % mod;
                if (i >= limit) {
                    sum1[j] = (sum1[j] + mod - f[i - limit][j][1]) % mod;
                }
            }
        }
        return (f[z][o][0] + f[z][o][1]) % mod;
    }
};

参考

• newhar

给你一个大小为 m x n 的矩阵 grid 。最初，你位于左上角 (0, 0) ，每一步，你可以在矩阵中 向右 或 向下 移动。

在从左上角 (0, 0) 开始到右下角 (m - 1, n - 1) 结束的所有路径中，找出具有 最大非负积 的路径。路径的积是沿路径访问的单元格中所有整数的乘积。

返回 最大非负积 对 $10^9 + 7$ 取余 的结果。如果最大积为 负数 ，则返回 -1 。

注意取余是在得到最大积之后执行的。

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 15
• -4 <= grid[i][j] <= 4

思路

首先，这是一个典型的dp问题，要求从左上角到右下角的路径乘积和最大非负积 取余 的结果。

可以使用两个和gird大小一致的数组big,sml分别存放到某个位置（i,j）的最大和最小乘积。

计算时注意，最上一行没有来自上的计算，最左一行没有来自左的计算，所以计算时先初始化（0，0）位置的big[0][0]=sml[0][0]=grid[0][0],然后计算最上一行、最左一行，最后计算剩下的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Solution {
public:
    int maxProductPath(vector<vector<int>>& grid) {
        const int MOD = 1e9 + 7;
        int m = grid.size(), n = grid[0].size();
        
        vector<vector<long long>> big(m, vector<long long>(n));
        vector<vector<long long>> sml(m, vector<long long>(n));
        
        big[0][0] = grid[0][0];
        sml[0][0] = grid[0][0];
        
        for (int i = 1; i < m; ++i) {
            big[i][0] = sml[i][0] = (long long)big[i-1][0] * grid[i][0];
        }
        
        for (int j = 1; j < n; ++j) {
            big[0][j] = sml[0][j] = (long long)big[0][j-1] * grid[0][j];
        }
        
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                vector<long long> candidates = {
                    (long long)big[i-1][j] * grid[i][j],
                    (long long)sml[i-1][j] * grid[i][j],
                    (long long)big[i][j-1] * grid[i][j],
                    (long long)sml[i][j-1] * grid[i][j]
                };
                big[i][j] = *max_element(candidates.begin(), candidates.end());
                sml[i][j] = *min_element(candidates.begin(), candidates.end());
            }
        }
        
        return big[m-1][n-1] >= 0 ? (big[m-1][n-1] % MOD) : -1;
    }
};

给你一个二进制字符串 s 。你可以按任意顺序执行以下两种操作任意次：

• 类型 1 ：删除 字符串 s 的第一个字符并将它 添加 到字符串结尾。
• 类型 2 ：选择 字符串 s 中任意一个字符并将该字符 反转 ，也就是如果值为 '0' ，则反转得到 '1' ，反之亦然。

请你返回使 s 变成 交替 字符串的前提下， 类型 2 的 最少 操作次数 。

我们称一个字符串是 交替 的，需要满足任意相邻字符都不同。

• 比方说，字符串 "010" 和 "1010" 都是交替的，但是字符串 "0100" 不是。

提示：

• $1 <= s.length <= 10^5$
• s[i] 要么是 '0' ，要么是 '1' 。

思路

首先，目的是得到0101..或1010..样式的字符串。

类型1可以操作任意次，也就是说可以使用s+s的长度为 n 的子串和目标字符串进行比较。

使用cnt记录达到0101..需要进行的类型2操作数，n-cnt 就是达到0101..需要进行的类型2操作数。

每次向右滑动一位，出滑动窗口的字符与目标字符串对应位进行比较，若不同，则cnt–，因为之前记录时加入了修改用的操作数；进滑动窗口的字符与目标字符串对应位进行比较，若不同，同理，cnt++。

每滑一次，更新ans=min({ans,n-cnt,cnt})。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Solution {
public:
    int minFlips(string s) {
        int n = s.size();
        string tar = "01";
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            cnt += (s[i] != tar[i % 2]);
        }
        int ans = min({cnt, n - cnt});
        for (int i = 0; i < n; i++) {
            cnt -= (s[i] != tar[i % 2]);
            cnt += (s[i] != tar[(i + n) % 2]);
            ans = min({ans, cnt, n - cnt});
        }
        return ans;
    }
};

Alice 在给 Bob 用手机打字。数字到字母的 对应 如下图所示。

为了 打出 一个字母，Alice 需要 按 对应字母 i 次，i 是该字母在这个按键上所处的位置。

• 比方说，为了按出字母 's' ，Alice 需要按 '7' 四次。类似的， Alice 需要按 '5' 两次得到字母  'k' 。
• 注意，数字 '0' 和 '1' 不映射到任何字母，所以 Alice 不 使用它们。

但是，由于传输的错误，Bob 没有收到 Alice 打字的字母信息，反而收到了 按键的字符串信息 。

• 比方说，Alice 发出的信息为 "bob" ，Bob 将收到字符串 "2266622" 。

给你一个字符串 pressedKeys ，表示 Bob 收到的字符串，请你返回 Alice 总共可能发出多少种文字信息 。

由于答案可能很大，将它对 $10^9 + 7$ 取余 后返回。

提示：

• $1 <= pressedKeys.length <= 10^5$
• pressedKeys 只包含数字 '2' 到 '9' 。

题解

首先，这是一个动态规划问题，接收的字符串 pressedKeys 可以被分割成多个子问题，每个子问题都是一个子字符串，子字符串为同样字符。

结果为每个子问题的答案相乘并取模。

按键可以映射的字母数量决定子问题的动态规划状态转移方程。

按键 '2' 到 '6' 每个按键最多可以映射 3 个字母：

$dp[i] = dp[i-1] + dp[i-2] + dp[i-3]$

按键 '7' 和 '9' 每个按键最多可以映射 4 个字母，状态转移方程为：

$dp[i] = dp[i-1] + dp[i-2] + dp[i-3] + dp[i-4]$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class Solution {
public:
    int mod = 1e9 + 7;
    vector<long long> v3, v4;
    int f3(int a) {
        if (v3[a] == 0) {
            for (int i = 4; i <= a; i++) {
                if (v3[i] != 0)
                    continue;
                v3[i] = (v3[i - 1] + v3[i - 2] + v3[i - 3]) % mod;
            }
        }
        return v3[a];
    }
    int f4(int a) {
        if (v4[a] == 0) {
            for (int i = 5; i <= a; i++) {
                if (v4[i] != 0)
                    continue;
                v4[i] = (v4[i - 1] + v4[i - 2] + v4[i - 3] + v4[i - 4]) % mod;
            }
        }
        return v4[a];
    }
    int countTexts(string pressedKeys) {
        int k[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4};
        long long ans = 1;
        int n = pressedKeys.size();
        int si = max(n + 1, 10);
        v3.resize(si, 0), v4.resize(si, 0);
        v3[0] = 1, v3[1] = 1, v3[2] = 2, v3[3] = 4, v4[0] = 1, v4[1] = 1,
        v4[2] = 2, v4[3] = 4, v4[4] = 8;
        for (int i = 0; i < n; i++) {
            char c = pressedKeys[i];
            int j = i;
            while (j < n && pressedKeys[j] == c) {
                j++;
            }

            int cnt = j - i, kv = c - '0';
            if (k[kv] == 3) {
                ans = ans * (f3(cnt)) % mod;
            } else {
                ans = ans * (f4(cnt)) % mod;
            }
            i = j - 1;
        }
        return ans;
    }
};

这题前几个月做过，一开始没做出来，现在重新做了一遍。但是又没做出来，忘记了， 这也许就是错误局部性吧，一开始就做错的，后面很可能也会出错，一开始做对的话，后面也大概率会做对。要经常做，才能记住。

问题描述： 添加新文章或变化后，需要手动刷新才能看到更新

解决方案：

• 添加了 Jekyll Livereload 支持（ npm run start:live ）

• 配置了 Service Worker 自动更新检测

• 添加了 BrowserSync 作为可选方案 修改文件：

• package.json - 添加新脚本命令

• Gruntfile.js - 配置 BrowserSync

问题 2：还是会有刷新确认按钮

问题描述： 网站检测到更新时，会显示 “Content updated. REFRESH” 按钮，需要手动点击

解决方案：

• 修改 sw-registration.js ，移除手动刷新提示，改为直接自动刷新 修改文件：

• js/sw-registration.js - 移除 createSnackbar 调用，直接使用 location.reload()

问题 3：网站不停自动更新（无限循环）

问题描述： 打开网站后不停自动刷新

解决方案：

• 移除了自动刷新逻辑

• 改用 Stale-While-Revalidate 策略：先显示缓存，后台更新

• 用户下次访问时自然看到新内容 修改文件：

• sw.js - 移除 UPDATE_FOUND 消息发送

• js/sw-registration.js - 移除自动刷新

问题 4：删除的文章仍在网站上显示

问题描述： 从仓库删除的文章，网站上还能看到

解决方案：

• 优化 Service Worker 策略，HTML 页面优先从网络获取

• 检测到 404 时自动从缓存中删除

• 更新缓存版本，清理旧缓存 修改文件：

• sw.js - 实现智能缓存策略，导航请求优先网络

问题 5：导航栏显示文章标题

问题描述： 导航栏出现了文章标题（“编译实践Lv1. main 函数”）

根本原因：

• 之前误将一篇博客文章放到了 css/ 文件夹

• 那篇文章有 layout: post ，被 Jekyll 当作页面处理

• 导航栏循环显示所有有 title 的页面 解决方案：

• 彻底解决方案： 硬编码导航栏，只显示固定页面（Home、About、Archive）

• 从 git 历史中彻底移除误放的文章

• 清理临时文件 修改文件：

• _includes/nav.html - 硬编码导航链接，移除循环

• 删除了 css/2026-02-15-lv1-main-.md

问题 6：About 和 Archive 页面 404

问题描述： 点击导航栏的 About 和 Archive 跳转到 /about.html 和 /archive.html ，显示 404

原因：

• 博客使用 permalink: pretty 配置

• 正确的 URL 应该是 /about/ 和 /archive/ （带斜杠） 解决方案：

• 修改导航链接，使用正确的 pretty permalink 格式 修改文件：

• _includes/nav.html - 链接改为 /about/ 和 /archive/

📊 最终效果总结

🗂️ 所有修改的文件

1. package.json - 添加脚本命令和依赖
2. Gruntfile.js - 配置 BrowserSync
3. js/sw-registration.js - 移除自动刷新
4. sw.js - 智能缓存策略，多次版本更新（v1→v2→v3→v4→v5）
5. _config.yml - 更新 exclude 列表
6. _includes/nav.html - 硬编码导航，修复链接格式

• 配置实验环境的 Docker 容器, 并学习 Docker 的基本使用方法.
• 认识编译实践中用到的编译器中间表示: Koopa IR.
• 认识编译实践中开发的编译器的目标架构: RISC-V.

配置实验环境的 Docker 容器, 并学习 Docker 的基本使用方法.

安装Docker Desktop

使用docker

一、镜像相关常用命令

镜像是容器的 “模板”，所有容器都基于镜像创建，这部分是基础操作。

1. 拉取镜像（下载到本地）

如果本地没有该镜像，先从 Docker 仓库拉取（如果是私有仓库，需先docker login）：

powershell

1
2
3
4
5

# 拉取指定镜像（格式：docker pull 镜像名:标签，latest是默认标签可省略）
docker pull maxxing/compiler-dev:latest

# 简写（省略latest，效果同上）
docker pull maxxing/compiler-dev

• 作用：把远程仓库的maxxing/compiler-dev镜像下载到本地，后续创建容器无需重复下载；
• 场景：首次使用该镜像、需要更新镜像版本时。

2. 查看本地镜像

powershell

1
2
3
4
5

# 查看所有本地镜像（重点看REPOSITORY、TAG、IMAGE ID）
docker images

# 过滤查看指定镜像（只显示maxxing/compiler-dev）
docker images maxxing/compiler-dev

• 输出示例：

  1 2	REPOSITORY TAG IMAGE ID CREATED SIZE maxxing/compiler-dev latest 5bcecbbe34b6 3 months ago 4.14GB

• 场景：确认镜像是否已下载、查看镜像 ID / 大小等信息。

3. 查看镜像详情

powershell

1
2
3
4
5

# 查看镜像的详细信息（创建时间、作者、启动命令等）
docker inspect maxxing/compiler-dev:latest

# 简化查看：只提取镜像的默认启动命令 
docker inspect --format='{{.Config.Cmd}}' maxxing/compiler-dev:latest

• 场景：排查镜像默认启动命令、确认镜像配置是否符合预期。

4. 删除镜像

powershell

1
2
3
4
5

# 删除指定镜像（需确保无容器关联，否则加-f强制删除）
docker rmi maxxing/compiler-dev:latest

# 或用镜像ID删除（更精准）
docker rmi 5bcecbbe34b6

• 注意：如果有容器使用该镜像，需先删除容器（参考下文 “删除容器” 命令）；
• 场景：清理无用镜像、释放磁盘空间。

二、容器相关常用命令（基于 maxxing/compiler-dev 创建容器）

容器是镜像的 “运行实例”，这部分是使用镜像的核心操作。

1. 创建并启动容器

这是最常用的命令，直接创建并进入容器，避免启动后退出：

powershell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 方式1：临时交互（推荐测试用，退出容器即停止）
# -it：交互终端，/bin/sh：适配Alpine镜像（无bash），--name：自定义容器名（避免随机名称）
docker run -it --name compiler-dev-container maxxing/compiler-dev:latest /bin/sh

# 方式2：后台运行（长期使用，可随时进入）
# -d：后台运行，--restart=always：容器开机自启（可选）
docker run -d -it --name compiler-dev-container maxxing/compiler-dev:latest /bin/sh

# 方式3：映射端口/目录（映射本地目录到容器）
# -v：本地目录:Docker容器目录（实现文件共享），-p：本地端口:容器端口（网络映射）
docker run -it -v D:\DockerData\code:/root/code -p 8080:80 --name compiler-dev-container maxxing/compiler-dev:latest /bin/sh

• 参数说明：

  • -i：保持输入交互；-t：分配伪终端；-d：后台运行；
  • --name：给容器起固定名称（方便后续操作，比如compiler-dev-container）；
  • -v：目录挂载（本地D:\DockerData\code和容器/root/code双向同步）；
  • -p：端口映射（访问本地 8080 端口等价于访问容器 80 端口）；

• 场景：

  • 临时测试镜像：用方式 1；
  • 长期运行服务：用方式 2；
  • 需要读写本地文件 / 暴露端口：用方式 3。

2. 查看容器状态

powershell

1
2
3
4
5
6
7
8

# 查看运行中的容器
docker ps

# 查看所有容器（包括已停止的）
docker ps -a

# 只查看指定容器的状态（用容器名/ID）
docker ps -a --filter "name=compiler-dev-container"

• 输出关键字段：

  • STATUS：Up X minutes（运行中）/Exited (0) X minutes ago（已退出）；
  • NAMES：容器名（compiler-dev-container）；
  • CONTAINER ID：容器 ID（比如 37dadd02cbf2）；

• 场景：确认容器是否运行、查找容器 ID / 名称。

3. 进入运行中的容器

powershell

1
2
3
4
5

# 进入后台运行的容器
docker exec -it compiler-dev-container /bin/sh

# 或用容器ID进入（比如容器ID是37dadd02cbf2）
docker exec -it 37dadd02cbf2 /bin/sh

• 注意：必须确保容器处于 “Up” 状态（运行中），否则会提示 “container is not running”；
• 场景：在运行中的容器内执行命令、操作文件。

4. 启动 / 停止 / 重启容器

powershell

1
2
3
4
5
6
7
8

# 启动已停止的容器（用容器名/ID）
docker start compiler-dev-container

# 停止运行中的容器
docker stop compiler-dev-container

# 重启容器（先停止再启动）
docker restart compiler-dev-container

• 场景：

  • 容器意外停止：用docker start重启；
  • 调整容器配置后：用docker restart生效；
  • 不需要容器运行时：用docker stop停止（释放资源）。

5. 查看容器日志（排查问题）

powershell

1
2
3
4
5
6
7
8

# 查看容器的全部日志
docker logs compiler-dev-container

# 实时查看日志（类似Linux tail -f）
docker logs -f compiler-dev-container

# 查看最新100行日志
docker logs --tail=100 compiler-dev-container

• 场景：容器启动失败、运行异常时，通过日志排查原因（比如命令执行错误、文件缺失）。

6. 删除容器

powershell

1
2
3
4
5
6
7
8
9

# 先停止容器，再删除（推荐）
docker stop compiler-dev-container
docker rm compiler-dev-container

# 强制删除运行中的容器（不推荐，可能丢失数据）
docker rm -f compiler-dev-container

# 批量删除所有已停止的容器（清理垃圾）
docker container prune

• 场景：容器不再使用、需要重新创建容器时。

7.挂载目录

• 场景：需要在容器内读写本地文件时，通过目录挂载实现（比如-v D:\DockerData\code:/root/code）。

1
2
3
4
5
6
7
8

# 挂载本地目录到容器（读写模式）
docker run -it -v D:\DockerData\code:/root/code --name compiler-dev-container maxxing/compiler-dev:latest /bin/sh

# 挂载本地目录到容器（只读模式）
docker run -it -v D:\DockerData\code:/root/code:ro --name compiler-dev-container maxxing/compiler-dev:latest /bin/sh

# 基于maxxing/compiler-dev镜像创建名为mycp的交互式容器，挂载Windows D盘指定目录到容器/root/sysy-make-template，容器退出后自动删除并进入Shell交互界面
docker run -it --rm --name mycp -v /d/githubprojects/sysy-make-template:/root/sysy-make-template maxxing/compiler-dev /bin/sh

三、运维管理常用命令

1. 查看 Docker 系统信息

powershell

1
2
3
4
5

# 查看Docker整体信息（版本、镜像/容器数量、存储驱动等）
docker info

# 查看Docker版本
docker version

• 场景：排查 Docker 环境问题、确认版本兼容性。

2. 清理 Docker 垃圾（释放磁盘空间）

powershell

1
2
3
4
5

# 清理所有无用的镜像、容器、网络、缓存（安全）
docker system prune -a

# 只清理镜像缓存（保留镜像/容器）
docker builder prune

• 注意：docker system prune -a会删除未使用的镜像，执行前确认无需保留。

总结

以maxxing/compiler-dev:latest为例，核心常用命令可归纳为 3 类：

1. 镜像操作：docker pull（拉取）→ docker images（查看）→ docker inspect（详情）→ docker rmi（删除）；
2. 容器操作：docker run -it（创建启动）→ docker ps（查看状态）→ docker exec -it（进入容器）→ docker start/stop（启停）→ docker rm（删除）；
3. 运维操作：docker logs（查日志）→ docker system prune（清理垃圾）。

关键提醒：针对该镜像（Alpine 系统），创建容器时必须指定/bin/sh（而非/bin/bash），且加-it参数，否则容器会启动后立刻退出。

使用powershell

切换目录的正确写法

如果要切换到 C 盘根目录，正确命令有两种：

powershell

1
2
3
4
5

# 方法1：完整路径（最规范，推荐）
cd C:\

# 方法2：简写（PowerShell支持的盘符切换方式）
cd C:

其他常用的目录切换规范：

powershell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 切换到上级目录
cd ..

# 切换到用户主目录（比如C:\Users\你的用户名）
cd ~

# 切换到带空格的目录（必须用引号包裹）
cd "C:\Program Files"

# 切换到指定子目录（比如C盘下的Temp文件夹）
cd C:\Temp

PowerShell 命令的通用规范

• 路径区分大小写吗？：不区分（Windows 系统特性），cd C:\temp 和 cd C:\Temp 效果一样。
• 特殊字符处理：路径含空格 / 特殊符号（如&、(）时，必须用双引号""包裹。
• 命令别名：PowerShell 兼容部分 DOS/CMD 别名（比如cd等价于Set-Location，dir等价于Get-ChildItem），但推荐优先用完整命令（更易读）。
• 执行脚本 / 程序：当前目录下的脚本需要加./，比如./test.ps1（直接写test.ps1会报错）。

推荐的 PowerShell 学习 / 参考网站

1. 微软官方文档（最权威）

   • 地址：https://learn.microsoft.com/zh-cn/powershell/
   • 优势：全中文、覆盖基础到高级、示例丰富，包含命令参考、语法规范、最佳实践，是新手入门的首选。

2. PowerShell Gallery（命令 / 模块库）

   • 地址：https://www.powershellgallery.com/
   • 优势：可以查找官方 / 社区维护的 PowerShell 模块，附带使用示例，解决实际场景问题（比如文件处理、系统管理）。

3. SS64（速查手册）

   • 地址：https://ss64.com/ps/
   • 优势：按字母排序的 PowerShell 命令速查表，每个命令都有简洁的语法、示例，适合快速查阅（支持中英文）。

4. GitHub PowerShell 社区

   • 地址：https://github.com/PowerShell/PowerShell
   • 优势：查看 PowerShell 源码、提问题、看社区贡献的示例脚本，适合进阶学习。

认识编译实践中用到的编译器中间表示: Koopa IR.

运行hello world

具体环境

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# cat /etc/os-release
PRETTY_NAME="Ubuntu 24.04.3 LTS"
NAME="Ubuntu"
VERSION_ID="24.04"
VERSION="24.04.3 LTS (Noble Numbat)"
VERSION_CODENAME=noble
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=noble
LOGO=ubuntu-logo

步骤

把一个 Koopa IR 程序保存在了文件 hello.koopa 中 hello.koopa :

// SysY 中的 `putch` 函数的声明.
decl @putch(i32)

// 一个用来输出字符串 (其实是整数数组) 的函数.
// 函数会扫描输入的数组, 将数组中的整数视作 ASCII 码, 并作为字符输出到屏幕上,
// 遇到 0 时停止扫描.
fun @putstr(@arr: *i32) {
%entry:
  jump %loop_entry(@arr)

// Koopa IR 采用基本块参数代替 SSA 形式中的 Phi 函数.
// 当然这部分内容并不在实践要求的必选内容之中, 你无需过分关注.
%loop_entry(%ptr: *i32):
  %cur = load %ptr
  br %cur, %loop_body, %end

%loop_body:
  call @putch(%cur)
  %next = getptr %ptr, 1
  jump %loop_entry(%next)

%end:
  ret
}

// 字符串 "Hello, world!\n\0".
global @str = alloc [i32, 15], {
  72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 10, 0
}

// `main` 函数, 程序的入口.
fun @main(): i32 {
%entry:
  %str = getelemptr @str, 0
  call @putstr(%str)
  ret 0
}

运行

1
2
3

koopac hello.koopa | llc --filetype=obj -o hello.o
clang hello.o -L$CDE_LIBRARY_PATH/native -lsysy -o hello
./hello

什么是 Koopa IR

Koopa IR 是一种专为北京大学编译原理课程实践设计的教学用的中间表示 (IR), 它在设计上类似 LLVM IR, 但简化了很多内容, 方便大家上手和理解.

同时, 我们为 Koopa IR 开发了对应的框架 (koopa 和 libkoopa), 大家在使用 C/C++/Rust 编程时, 可以直接调用框架的接口, 实现 Koopa IR 的生成/解析/转换.

Koopa IR 是一种强类型的 IR, IR 中的所有值 (Value) 和函数 (Function) 都具备类型 (Type). 这种设计避免了一些 IR 定义上的模糊之处, 例如之前的教学用 IR 完全不区分整数变量和数组变量, 很容易出现混淆; 同时可以在生成 IR 之前就确定 IR 中存在的部分问题, 例如将任意整数作为内存地址并向其中存储数据.

Koopa IR 中, 基本块 (basic block) 必须是显式定义的. 即, 在描述函数内的指令时, 你必须把指令按照基本块分组, 每个基本块结尾的指令只能是分支/跳转/函数返回指令之一. 在 IR 的数据结构表示上, 指令也会被按照基本块分类. 这很大程度上方便了 IR 的优化, 因为许多优化算法都是在基本块的基础上对程序进行分析/变换的.

Koopa IR 还是一种 SSA 形式的 IR. 虽然这部分内容在课程实践中并非必须掌握, 但考虑到有些同学可能希望在课程实践的要求上, 做出一个更完备, 更强大的编译器, 我们将 Koopa IR 设计成了同时兼容非 SSA 形式和 SSA 形式的样子. 基于 SSA 形式下的 Koopa IR, 你可以开展更多复杂且有效的编译优化.

— 引自 北大编译实践在线文档

• LLVM IR（Intermediate Representation）: 是LLVM编译器架构中的一种中间表示形式，它充当编译器前端和后端之间的桥梁。LLVM IR设计为与特定目标机器无关，使得编译器能够支持多种源语言并为多种目标生成代码。LLVM IR在编译过程中起到至关重要的作用，因为它是大多数目标无关优化发生的地方。

• SSA形式（Static Single Assignment Form）: 是一种程序表示形式。SSA形式要求每个变量在程序中只能被赋值一次，这意味着每个变量的定义（def）和使用（use）关系非常明确。变量的生命周期从第一次定义到最后一次使用，这种清晰的结构使得编译器能够更容易地进行数据流分析和优化。

认识编译实践中开发的编译器的目标架构: RISC-V.

在编译实践中, 你将开发一个生成 RISC-V 汇编的编译器. 那么首先, 什么是 RISC-V?

RISC-V, 读作 “risk-five”, 是由加州大学伯克利分校设计并推广的第五代 RISC 指令系统体系结构 (ISA). RISC-V 没有任何历史包袱, 设计简洁, 高效低能耗, 且高度模块化——最主要的, 它还是一款完全开源的 ISA.

RISC-V 的指令系统由基础指令系统 (base instruction set) 和指令系统扩展 (extension) 构成. 每个 RISC-V 处理器必须实现基础指令系统, 同时可以支持若干扩展. 常用的基础指令系统有两种:

• RV32I: 32 位整数指令系统.
• RV64I: 64 位整数指令系统. 兼容 RV32I.

常用的标准指令系统扩展包括:

• M 扩展: 包括乘法和除法相关的指令.
• A 扩展: 包括原子内存操作相关的指令.
• F 扩展: 包括单精度浮点操作相关的指令.
• D 扩展: 包括双精度浮点操作相关的指令.
• C 扩展: 包括常用指令的 16 位宽度的压缩版本.

我们通常使用 RV32/64I + 扩展名称的方式来描述某个处理器/平台支持的 RISC-V 指令系统类型, 例如 RV32IMA 代表这个处理器是一个 32 位的, 支持 M 和 A 扩展的 RISC-V 处理器.

在课程实践中, 你的编译器将生成 RV32IM 范围内的 RISC-V 汇编.

— 引自 北大编译实践在线文档

参考

• 北大编译实践在线文档
• docker文档
• doubao

给你一个长度为 n 的整数数组 nums。

三段式子数组 是一个连续子数组 nums[l…r]（满足 0 <= l < r < n），并且存在下标 l < p < q < r，使得：

nums[l…p] 严格 递增， nums[p…q] 严格 递减， nums[q…r] 严格 递增。 请你从数组 nums 的所有三段式子数组中找出和最大的那个，并返回其 最大 和。

提示:

$4 <= n = nums.length <= 10^5$

$-10^9 <= nums[i] <= 10^9$

保证至少存在一个三段式子数组。

思路

由于l < p < q < r, $p$ 是第一段的终点和第二段的起点，$q$ 是第二段的终点和第三段的起点，我们可以通过预处理和线性扫描来解决。

• preSum[i]: 以 $i$ 结尾且满足“严格递增”的最大子数组和。

  条件：必须包含 $nums[i]$ 和 $nums[i-1]$。

  公式：如果 $nums[i] > nums[i-1]$，$preSum[i] = \max(nums[i] + nums[i-1], preSum[i-1] + nums[i])$。

• sufSum[i]: 以 $i$ 开头且满足“严格递增”的最大子数组和。

  条件：必须包含 $nums[i]$ 和 $nums[i+1]$。

  公式：如果 $nums[i] < nums[i+1]$，$sufSum[i] = \max(nums[i] + nums[i+1], sufSum[i+1] + nums[i])$。

如果前面的和已经变成负数，我们应当果断抛弃旧的部分，从当前能构成的最短合法子数组重新开始计算。

最后，我们枚举每一个可能的递减段 $[p...q]$。只要满足 $nums[p] > nums[p+1] > \dots > nums[q]$，我们就尝试用 preSum[p] + (中间段的和) + sufSum[q] 来更新答案。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

class Solution {
public:
    long long maxSumTrionic(vector<int>& nums) {
        int n = nums.size();
        
        vector<long long > pre(n,LLONG_MIN),suf(n,LLONG_MIN);

        for(int i=1;i<n;i++){
            if(nums[i]>nums[i-1])
            {
            long long bs=(i>1&&pre[i-1]!=LLONG_MIN)?pre[i-1]:nums[i-1];
            pre[i]=max((long long)nums[i]+nums[i-1],bs+nums[i]);
            }
        }
        for(int i=n-2;i>=0;--i){
            if(nums[i+1]>nums[i])
            {
            long long bs=(i+2<n&&suf[i+1]!=LLONG_MIN)?suf[i+1]:nums[i+1];
            suf[i]=max((long long)nums[i+1]+nums[i],bs+nums[i]);
            }
        }
        long long ans=LLONG_MIN;
        for(int i=0;i<n-1;i++){
            if(nums[i]>nums[i+1]){
                int p=i;

                long long t=nums[i];

                while(i<n-1&&nums[i]>nums[i+1]){
                    ++i;
                    t+=nums[i];
                    if(pre[p]!=LLONG_MIN&&suf[i]!=LLONG_MIN){

                        ans=max(ans,t+pre[p]+suf[i]-nums[i]-nums[p]);
                    }
                }
                i--;


            }
        }
        return ans;
    }
};

简单来说，set是一个集合，里面的元素是唯一的，而且是有序的。

set是一个容器，可以提供快速的查找、插入和删除操作,具有对数复杂度。

set 通常实现为 红黑树。

怎么用set

迭代器

• begin      返回指向起始的迭代器
• cbegin (C++11)      (public 成员函数)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <algorithm>
#include <iostream>
#include <set>
 
int main()
{
    std::set<int> set{3, 1, 4, 1, 5, 9, 2, 6, 5};
    // std::for_each(set.begin(), set.end(), [](int x)
    // {
    //     std::cout << x << ' ';
    // });
    std::cout<<*set.begin();
    std::cout << '\n';
}

• end      返回指向末尾的迭代器
• cend (C++11)      (public 成员函数)

cbegin()和cend()是C++11新增的，它们返回一个const的迭代器，不能用于修改元素。

• rbegin      返回指向起始的逆向迭代器

• crbegin (C++11)      (public 成员函数)

• rend      返回指向末尾的逆向迭代器

• crend (C++11)      (public 成员函数)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <iostream>
#include <set>
 
int main()
{
    std::set<unsigned> rep{1, 2, 3, 4, 1, 2, 3, 4};
 
    for (auto it = rep.crbegin(); it != rep.crend(); ++it)
    {
        for (auto n = *it; n > 0; --n)
            std::cout << "⏼" << ' ';
        std::cout << '\n';
    }
}

容量

• empty      检查容器是否为空

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <iostream>
#include <set>
 
int main()
{
    std::set<int> numbers;
    std::cout << std::boolalpha;
    std::cout << "Initially, numbers.empty(): " << numbers.empty() << '\n';
 
    numbers.insert(42);
    numbers.insert(19937);
    std::cout << "After adding elements, numbers.empty(): " << numbers.empty() << '\n';
}

• size      返回元素数量

1
2
3
4
5
6
7
8

#include <cassert>
#include <set>
 
int main()
{
    std::set<int> nums{4, 2, 4, 2};
    assert(nums.size() != 2);
}

• max_size      返回元素的最大可能数量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>
#include <locale>
#include <set>
 
int main()
{
    std::set<char> p;
    std::set<long> q;
 
    // std::cout.imbue(std::locale("en_US.UTF-8"));
    std::cout << std::uppercase
              << "p.max_size() = " << std::dec << p.max_size() << " = 0x"
              << std::hex << p.max_size() << '\n'
              << "q.max_size() = " << std::dec << q.max_size() << " = 0x"
              << std::hex << q.max_size() << '\n';
}

修改器

• clear      清除内容

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <string_view>
#include <set>
 
void print_info(std::string_view rem, const std::set<int>& v)
{
    std::cout << rem << "{ ";
    for (const auto& value : v)
        std::cout << value << ' ';
    std::cout << "}\n";
    std::cout << "Size=" << v.size() << '\n';
}
 
int main()
{
    std::set<int> container{1, 2, 3};
    print_info("Before clear: ", container);
    container.clear();
    print_info("After clear: ", container);
}

• insert      插入元素 或节点 (C++17 起)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <cassert>
#include <iostream>
#include <set>
 
int main()
{
    std::set<int> set;
 
    auto result_1 = set.insert(3);
    assert(result_1.first != set.end()); // it is a valid iterator
    assert(*result_1.first == 3);
    if (result_1.second)
        std::cout << "insert done\n";
 
    auto result_2 = set.insert(3);
    assert(result_2.first == result_1.first); // same iterator
    assert(*result_2.first == 3);
    if (!result_2.second)
        std::cout << "no insertion\n";

    for(auto it:set){
       std:: cout<<it<<"\n";
    }
}

• insert_range (C++23)      插入元素范围

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21