现在我们带你讲解一下一个汇编语言程序是怎么写的。x86 汇编语言由语句 (statement) 构成，一条语句可能有以下元素：

7.1 常量整数和常量整数表达式

一个常量整数表示为 [{ + | - }] 数字 { 基数字符 }，例如 -10、11010011b、0A3h。

标识说明：

• [] 的内容是可选的
• { A | B } 说明必须在 A 和 B 中选择一项

基数字符说明了此整数使用的数制，如下表所示：

如果一个十六进制值以字母开头，如 A4，则必须加上前缀 0 以免和变量名混淆。

整数字面量间的运算使用以下运算符：

每个表达式的计算结果必须为可存储为 32 位的整型（0 ~ FFFFFFFF），此结果在编译时确定，运行时不可变。

EQU 指令可以设置符号整数常量，相当于 C 中的 #define，格式为 标识符 EQU 常量整数表达式。EQU 定义的常量在汇编时直接替换为字面量，因此运行时固定不可变。更宽松的版本是 = 指令，允许常量重定义，但依然是汇编时确定，运行时不可更改。

7.2 其他常量

常量实数表示为 [{ + | - }]数字.[数字][指数]，其中[指数]为科学记数法中的 $×10^{n}$ 部分，表示为 E[{ + | - }]integer。2.、-44.2E+05、26.E5 都是合法的十进制实数。常量实数按照 IEEE 浮点数格式转换存储。

编码实数 (encoded real) 以十六进制表示，用 r 结尾。对应的十六进制从 IEEE 浮点数格式的二进制数转换得到，如 +1.0 的 IEEE 浮点数格式为 0011 1111 1000 0000 0000 0000 0000 0000，编码实数表示为 3F800000r

字符和字符串常量以 ''/"" 包围，按照 ASCII 码存储。

7.3 保留字

保留字主要有以下类型：

• 指令助记符，如 mov、add、mul 等
• 寄存器名称
• 汇编器指令
• 类型属性，如 byte 和 word
• 运算符
• 预定义的符号

保留字大小写不敏感，如 MOV 和 mov 是一样的，但预定义符号除外。

7.4 标识符

标识符用于标识变量、常量、函数、标签，有以下规则：

• 长度在 1 ~ 247 之间
• 大小写不敏感（通过汇编器的 -Cp 选项可使之大小写敏感）
• 首字符必须是字母、下划线、@、? 或 $，后续的字符才可以取数字。
  作为建议，请尽量不要以下划线或者 @ 开头，减少违反下一条规则的概率。
• 不能和保留字撞名

7.5 指令

指令在汇编时转换成运行时可执行的语句（机器语言字节）。一条指令包含四个部分：[标签:] [助记符] [操作数] [;注释]

• 标签
  标签用于标识数据 / 代码的位置。

• 助记符
  助记符标识指令功能。

• 操作数
  操作数用于指令数据的输入输出。操作数可以是寄存器 (reg)、内存地址 (mem) 或者整数表达式 (imm)。一条指令可以有 0 到 3 个操作数。
  对于有两个操作数的指令，第一个操作数作为目标操作数 (dest)，第二个操作数作为源操作数 (src)。指令一般修改的是目标操作数。
  对于有三个操作数的指令，后两个操作数作为源操作数执行指令，结果存储到目标操作数。
  常见助记符及其操作数：

  助记符	操作数	说明
  MOV	dest, src	src 的值赋值到 dest
  ADD	dest, src	dest = dest + src
  INC	op	op 递增 1
  DEC	op	op 递减 1
  SUB	dest, src	dest = dest - src
  MUL	op	无符号乘法，结果储存在主寄存器中，即 EAX = EAX * op
  IMUL	dest, src1, src2	有符号乘法，dest = src1 * src2
  JMP	label	无条件跳转至标签位置
  CALL	func	调用函数
  NOP	无	无操作指令，占用 1 字节，常被汇编器用于字节对齐

  Note

  无论何时，我们都建议优先以寄存器作为操作数，然后是常量值，最后才是内存地址标识，因为它们的读取效率是依次递减的。

• 注释
  单行注释以 ; 开头
  多行注释使用 COMMENT 指令，语法为 COMMENT 结束符。从 COMMENT 到第一个结束符之间的代码块将被忽略。

7.6 段式存储

正如 4.2 所述，x86 处理器底层依然属于段式存储模型。在大部分操作系统上，采用的模型和各位在 C / C++ 学的内存布局是一样的。

现在这个阶段，需要我们设置的内存段只有 .data（数据段）和 .code（代码段）。

7.7 示例 1

下面是一个进行加减运算的 MASM 汇编程序，操作数是写死在程序中的。

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

INCLUDE Irvine32.inc

.code
main PROC

a:
mov eax,30000h; EAX = 10000h
add eax,80000h; EAX = 50000h
sub eax,20000h; EAX = 30000h
; jmp a           ; jump to label 'a'
call DumpRegs

exit
main ENDP
END main

我们详细分析一下这个程序。第一部分是汇编器指令：

• INCLUDE Irvine32.inc 调用了教学用库 Irvine32.inc

接下来是代码区，我们在这里写函数代码：

• .code 表示下面的所有代码均属于代码段的内容
• main PROC 定义 main 过程（Procedure，即函数）
• a: 定义了一个标签 a，指向 mov eax, 30000h
• mov eax, 30000h 将十六进制值 30000h 赋值给 eax
• add eax, 80000h 将 80000h 和 eax 的值相加，结果保存到 eax。
• call DumpRegs 调用 Irvine32.inc 的 DumpRegs 函数，作用是打印当前的寄存器数值
• jmp a 表示无条件跳转到 a 指向的代码。由于有个 bug 故注释，注意到了么？
• exit 是系统调用 (system call)，表示程序的退出。注意不要对主函数使用 ret，因为 ret 需要显式调用方
• main ENDP 表示结束此过程的定义
• END main 表示整个源文件结束，并且指定了入口点函数 main。

7.8 数据类型与数据操作

MASM 内建以下数据类型：BYTE, SBYTE（有符号字节）, WORD, SWORD, DWORD, SDWORD, FWORD（六字节）, QWORD, TBYTE（十字节）。主要使用 BYTE, WORD, DWORD, QWORD 类型，可分别简写为 db, dw, dd, dq。

使用 TYPEDEF 可以定义新的类型，包括指针，语法为 类型名 TYPEDEF [PTR] 已注册的类型。已注册的类型包括内建类型和已使用 TYPEDEF 注册过的类型，例如：

1
2

CHAR    TYPEDEF BYTE
PCHAR   TYPEDEF PTR CHAR

使用数据类型在 .data 段定义数据的语法为 [标识符] 类型 [初始化值, ...]

1
2

count dword 114514
homo  word  ?

数据定义时必须有至少一个初始化值，如果不想自己设定，可以使用 ? 表示随机赋值。所有的初始化值，无论其格式，都会被汇编器转换为二进制数据。如果初始化值是有规律重复的，可以使用 DUP (Duplicate) 命令：

1
2
3

BYTE 20 DUP(0) ; 20 字节，均初始化为 0
BYTE 20 DUP(?) ; 20 字节，均随机初始化
BYTE 4 DUP("STACK") ; 20 字节，一个字符串："STACKSTACKSTACKSTACK"

可以有多个初始化值，这实际上就声明了一个数组：

1
2

list  byte  10,20,30,40
      byte  50,60,70,80

数据 10 位于 list 的偏移 0 位置，以此类推。

字符串也是一种数组，但作为例外，每个字节间不都需要逗号分隔。正如各位在 C 中所学的那样，所有的字符串都需要加一个 \0 终止符（当然，是手动的，没有编译器兜底了）。对于多行字符串，只需要一整块字符串的末尾终止即可，如果需要换行，需要使用 0dh, 0ah (CR/LF)：

1
2
3
4

greeting1 BYTE "Welcome to the Encryption Demo program "
          BYTE "created by Kip Irvine.",0dh,0ah
          BYTE "If you wish to modify this program, please "
          BYTE "send me a copy.",0dh,0ah,0

计算数组长度可以使用 $ - Array，例如：

1
2

list BYTE 10,20,30,40
ListSize = ($ - list) ; ListSize = 4

如果是字符串长度，需要减去使用的转义字符的长度：

1
2

hello BYTE "Hello",0
StringSize = ($ - hello) - 1 ; StringSize = 5

注意采用这种方式计算的，表达式必须紧跟在数组之后，因为 ($ - list) 的语义是当前地址 ($) 减去 list 的地址。数据在段内是连续的，因此可以用偏移值计算元素个数。如果中间再插入了其他数据，偏移值就计算错误了。

BYTE 只占 1 字节，因此偏移值 = 元素数。如果是 WORD 等更大的数据类型，就需要除以它的单位长度，例如：

1
2

data WORD 1,1,4,5,1,4
dataSize = ($ - data) / 2 ; $ - data = 12, dataSize = 6

可以在代码段中间夹杂数据段。数据的作用域从声明位置开始：

1
2
3
4
5
6

.code
mov eax,ebx
.data
temp DWORD ?
.code
mov temp,eax

在进行数据的转移时，数据的宽度必须匹配目标寄存器的宽度。由于寄存器的宽度可以 “分割”，会出现数值覆盖 (Overlapping Values) 的情况：

1
2
3
4
5
6
7
8
9
10
11

.data
oneByte BYTE 78h
oneWord WORD 1234h
oneDword DWORD 12345678h

.code
mov eax,0 ; EAX = 00000000h
mov al,oneByte ; EAX = 00000078h
mov ax,oneWord ; EAX = 00001234h
mov eax,oneDword ; EAX = 12345678h
mov ax,0 ; EAX = 12340000h

数值仅覆盖对应位数，而其他位不变。对于有符号数，这种情况更加复杂：

1
2
3
4
5

.data
signedVal SWORD -16 ; FFF0h (-16)
.code
mov ecx,0
mov cx,signedVal ; ECX = 0000FFF0h (+65,520)

明明存储的是负数，结果读 ECX 的时候却读出了正数！除了尽量保证使用 CX，我们也可以先将 ECX 赋值为 FFFFFFFFh，这样数值就是正确的 FFFFFFF0h 了，这被称为符号位扩展 (Sign Extension)。为了简便较小宽度的数据向较大宽度的寄存器的转移， x86 设计了两个指令：

• MOVZX (Move with Zero eXtension)

适用于无符号数，将扩展的位数设置为 0。

• MOVSX (Move with Sign eXtension)

适用于有符号数，将扩展的位数设置为 1。

1
2
3
4
5

.data
byteVal BYTE 10001111b
.code
movzx ax,byteVal ; AX = 0000000010001111b
movsx bx,byteVal ; BX = 1111111110001111b

1
2
3

reg32, reg/mem8
reg32, reg/mem16
reg16, reg/mem8

你如果还记得 C 语言的话，估计会把交换数据写成三个存储位置的中转交换，但 x86 提供了 XCHG (eXchange data)，可以直接交换数据：

1
2
3

XCHG reg,reg
XCHG reg,mem
XCHG mem,reg

对于两个内存数据的交换，需要使用寄存器中转：

1
2
3

mov ax,val1
xchg ax,val2
mov val1,ax

7.9 操作数和寻址方式

正如我们在 7.5 所述，操作数可以是寄存器、内存地址或者整数表达式。我们将这些操作数分类为：立即数、寄存器和内存，由此得到几种寻址模式：

• 立即数寻址

立即数就是内存中的字面量，因此立即数可以直接写在指令中：

1
2
3
4

mov eax, 10h

; View in Hex:
; B8 10000000

• 直接内存寻址

地址需要解引用以访问对应数据。不过相比直接写地址值，我们一般都使用变量名，因为变量名携带了相对与段基地址的偏移信息。

1
2
3
4
5

mov eax, var1

; Suppose var1 were located at offset 10400h
; View in Hex:
; A1 00040100

1
2

mov eax, var1
mov var2, eax

• 直接寄存器寻址

7.10 示例 2

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

INCLUDE Irvine32.inc

.data
greeting byte "Hello, World!", 0

.code
main PROC
mov  edx, OFFSET greeting
call WriteString

exit
main ENDP
END  main

此处我调用了 Irvine32.inc 的 WriteString 函数。它以 edx 作为参数，接受字符串地址，将含终止符的字符串打印到标准输出。

7.11 基本运算

基本运算指令分为算术运算和逻辑运算。所有运算都会同步修改标志寄存器。

7.11.1 加减运算

INC 和 DEC 指令的作用是对寄存器 / 内存的值递增 (Increase) 和递减 (Decrease) 1，操作数就一个，运算结果保存到操作数上。

ADD 和 SUB 指令分别为加法 (Add) 和减法 (Substraction)，操作数是 dest,src，运算结果保存到 dest，不修改 src

NEG 是取反 (Negate) 指令，就是将寄存器 / 内存的值的符号位取反。

7.11.2 乘除运算

7.11.3 位运算

8. 分支与循环程序设计

默认情况下，CPU 按顺序加载和执行程序。但条件指令会根据 CPU 状态标志的值（Zero、Sign、Carry 等）将控制权转移到程序中的新位置。控制转移分为两种：无条件转移和条件转移。

循环在这里视为分支，因为它也可以使用条件转移指令实现。

8.1 无条件转移

使用 JMP 指令：

1

JMP label

CPU 将自动将 label 转换成偏移值，赋值给 IP 以在新位置执行代码。

JMP 是创建循环的最简单方法，结合标签可以形成一个无限循环：

1
2
3

top:
  ; ...
  jmp top

8.2 条件转移

只有判断标志寄存器的值满足条件时，条件指令才跳转。由于标志寄存器不能直接设定，因此需要搭配 cmp (compare) 或 test 指令使用。

cmp 的底层逻辑是 A - B，用于判断两个数的大小。test 的底层逻辑是 A & B，用于检查特定位数的状态（test A,A 可以判断 A 是否为 0）。两个指令均只修改 FLAGS 寄存器而不破坏元数据。

常见条件转移指令：

其实记忆这些指令并不难，因为它们都是 JMP + 条件缩写的形式。

条件转移可以形成一个有限循环：

1
2
3
4
5
6
7
8
9
10

; ...
mov ecx, a_len
copy:
    mov eax, a[esi]
    mov b[esi], eax
    add esi, 4
    dec ecx
    cmp ecx, 0
    jne copy
; ...

有一个专门的指令 LOOP 同样实现了有限循环，以 ECX 作为循环次数，当其数值减少到 0 时，LOOP 指令就会停止，继续执行下面的指令。

1
2
3
4
5
6
7
8

; ...
mov ecx, a_len
copy:
    mov eax, a[esi]
    mox b[esi], eax
    add esi, 4
    loop copy
; ...

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

.data
count dword ?
.code
mov ecx,100 ; set outer loop count
L1:
mov count,ecx ; save outer loop count
mov ecx,20 ; set inner loop count
L2:
; ...
loop L2

mov ecx,count ; restore outer loop count
loop L1

9. 函数

通俗地说，我们可以将函数（Procedure，本义为过程，有人也称为子程序）定义为一个返回语句结束的语句块。函数是使用 PROC 与 ENDP 指令声明的。它必须被赋予一个合法的标识符。

对于非入口点函数（即 main），使用 RET 作为返回语句：

1
2
3
4

sample PROC
; ...
ret
sample ENDP

函数内标签的作用域仅限于此函数内，这主要影响跳转与循环指令。虽然可以通过标签名后标识 :: 来声明一个全局标签，但这样做容易破坏程序的运行时栈 (Runtime Stack)。关于运行时栈我们会更详细地介绍。

这是一个简单的加法函数，约定参数和返回值都通过寄存器传递，比较简单：

1
2
3
4
5

SumOf PROC
    add eax,ebx
    add eax,ecx
    ret
SumOf ENDP

现在你可以使用 CALL 指令调用函数了！Irvine32.inc 实现了一些简单的输入输出函数。你可以直接打开此文件查看此库声明了哪些函数。

9.1 运行时栈

运行时栈用于存储函数执行期间的必要的临时信息。和数据结构中的 “栈” 一样，运行时栈同样遵循 LIFO 规则。运行时栈通过 ESP 寄存器管理地址。一般来讲，我们不会直接修改 ESP，而是通过 CALL、RET、PUSH 和 POP 指令间接修改。

ESP 永远指向最后一个压入栈的值，即栈顶。这里需要注意一下，在操作系统中，栈是 “向下生长” 的，即栈的地址是从高到低的。每当我们 PUSH 一个值进入栈，ESP 的值会递减，然后将操作数复制到栈里。一个 16 bits 操作数会使 ESP 递减 2，32 bits 则递减 4。PUSH 的操作数可以是寄存器、内存地址或立即数。

POP 会将 ESP 指向的栈内容复制到操作数中，然后递增 ESP。POP 的操作数可以是寄存器或内存地址。

9.2 函数调用

CALL 指令可以让 CPU 跳转到函数内存位置以执行指令。与之配套的是函数内的 RET 语句。

具体来讲，CALL 将返回地址压入栈中，然后将目标函数地址赋值给 EIP。返回地址指向 CALL 的下一条语句。当函数 RET 时，栈中存放的返回地址赋值给 EIP，之后弹出。

因此，对于一个正常的程序，其调用函数前后的堆栈是平衡的，即在 RET 时 ESP 的值应该和 CALL 时返回地址压入后的 ESP 值相等，这样 RET 才能将正确的返回地址写入 EIP。

对于函数的嵌套调用同样如此。每 CALL 一个子函数，对应的返回地址就会压入栈中；系统在同一时间内只会执行位于运行时栈栈顶的那个函数；然后 RET 时不断 “溯源”，直到返回主函数。

9.3 保存和恢复寄存器

现在我们准备写一个更复杂的函数：

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

;----------------------------------------------------
; ArraySum 
;  
; Calculates the sum of an array of 32-bit integers. 
; Receives: ESI = the array offset 
;           ECX = number of elements in the array 
; Returns: EAX = sum of the array elements 
;----------------------------------------------------
ArraySum PROC
push esi ; save ESI, ECX
push ecx
mov eax,0 ; set the sum to zero
L1:
  add eax,[esi] ; add each integer to sum
  add esi,TYPE DWORD ; point to next integer
loop L1

pop ecx ; restore ECX, ESI
pop esi
ret

ArraySum ENDP

此函数通过寄存器传递参数和返回值，不使用特定标识符以提高兼容性。

不过我们不是想聊这个。看这个程序的开头，它将 ESI 和 ECX 的值压入栈中，而返回前又将其 POP 出来。这是大多数修改寄存器的函数的典型做法：始终保存并恢复被函数修改的寄存器，以确保调用者自身的寄存器值不会被覆盖。该规则的一个例外是用作返回值的寄存器，一般是 EAX。

你可以通过 USES 指令让汇编器自动生成这类代码：

1
2
3
4
5
6
7
8
9
10

ArraySum PROC USES esi ecx
mov eax,0 ; set the sum to zero
L1:
  add eax,[esi] ; add each integer to sum
  add esi,TYPE DWORD ; point to next integer
loop L1

ret

ArraySum ENDP

USES 紧跟在 PROC 之后，寄存器列表中间无逗号。

1
2
3
4

ArraySum PROC USES esi ecx
push ebp
mov  ebp,esp
; ...

1
2
3
4
5

push esi
push ecx
push ebp
mov  ebp,esp
; ...

或者使用 pushad 和 popad （ad 代表 All Double）将所有的通用寄存器都 push / pop。

9.4 用栈传递参数

本节开头我们展示了如何用寄存器传递参数。然而，大多数现代语言中函数参数是通过堆栈传递的：在 32 位下，Windows API 的参数也通过栈传递。因此，必须学会如何用栈传递参数。

9.4.1 栈帧

当函数被调用时，运行时栈会预留一块区域，称为栈帧（Stack Frame，或活动记录 Activation Record）。栈帧存放着函数的实参、返回地址、局部变量和保存的寄存器。一个栈帧由以下步骤建立：

1. 传递的实参被压入堆栈。
2. 调用函数，使函数返回地址被推送到栈上。
3. 当函数开始执行时，EBP 会被推送到堆栈上。
4. EBP 设置成和 ESP 相等。从此，EBP 作为函数形参的基址参考。
5. 如果存在局部变量，需要递减 ESP 以预留堆栈上的变量空间。
6. 需要保护的寄存器被推送到堆栈中。

汇编的传参形式有两种：值传参和引用传参。

数组必定使用引用传参，因为值传参代表它需要将每个元素都压入栈。使用 OFFSET 指令。

9.4.2 栈参数的调用和清理

现在我们来一个示例：

1
2
3
4
5
6
7
8

AddTwo PROC
  push ebp
  mov  ebp,esp
  mov  eax,[ebp + 12]
  add  eba,[ebp + 8]
  pop  ebp
  ret
AddTwo ENDP

使用栈传参时，需要将 EBP 压入栈，ESP 由系统自动管理，不需要我们操心。

如果我们调用了 AddTwo(5,6)，即：

1
2
3

push 6
push 5
call AddTwo

那么它的栈结构大概长这样：

如果我们想访问参数，那么用相对寻址。像 [ebp + 12] 这样用表达式引用实参的，我们称为显式栈参数 (Explicit Stack Parameter)。

有一个问题不知道你发现了没有：既然返回地址在实参下面，而当返回地址被弹出时，函数也退出了，那么剩下的实参怎么处理？

很遗憾，操作系统并不会在程序运行过程中自动回收它们。忽略它们？如果只用一层调用还好，但如果是嵌套调用呢？内层函数残留的栈实参在外层函数返回地址的下面，而 ESP 会读取实参作为地址！还记得我们在 C / C++ 所说的吗？标准结局就是内存访问冲突。

清理的理由有了，但怎么清理？POP 可不能把立即数 POP 出去啊。那么，既然栈实参不能物理移除，可不可以直接跳过它呢……

9.4.3 调用约定

调用约定 (Calling Convention) 确定了函数传参的传参形式、压栈顺序、返回值存储和清除栈方式。在 x86 Windows 下有两个主要的调用约定：C 调用约定 (CDECL) 和 STDCALL 调用约定。

C 调用约定和 STDCALL 的压栈顺序一致，即从右到左倒序压栈。而清除栈方式不一样：

• C 调用约定是调用者清除 (Caller Cleanup)，在调用函数 CALL 的下一行对 ESP 进行加法，其值等于被调用函数参数的总大小。
• STDCALL 是被调用者清除 (Callee Cleanup)，给予被调用函数 RET 一个操作数，其值等于被调用函数参数的总大小。此时系统会自动向 ESP 增加值。

STDCALL 可以确保调用者不会忘记清理栈，而 C 调用约定允许可变数量参数。

FASTCALL 使用 ECX 和 EDX 传递前两个参数，之后的参数使用栈传递。

所有调用约定的整数返回值均通过 EAX 返回。

如果压栈参数在寄存器里，将寄存器压入栈，那么由调用者恢复寄存器：

1
2
3
4
5
6

mov ecx,eax
push ecx
push OFFSET Array
call some_func
add esp,4
pop ecx

压栈的参数长度必须为 4 字节（32 bit 下）。如果值传参发现参数长度不是 4 字节，则应该换用引用传参。

9.5 引用传参的使用

引用参数通常使用间接寻址访问。比如将一个数组的引用传递给 ESI：

1
2
3
4
5
6

mov esi,[ebp+12] ; offset of array
mov ecx,[ebp+8] ; array length
; ...
mov [esi],ax ; insert value in array
add esi,TYPE WORD ; move to next element
; ...

9.6 综合示例

对于计科的同学，课程要求就到这里。

函数调用时的具体步骤如下：

1. 主调函数将被调函数所要求的参数，根据相应的函数调用约定，保存在运行时栈中。该操作会改变程序的栈指针。
2. 主调函数将控制权移交给被调函数（使用 CALL 指令）。函数的返回地址（待执行的下条指令地址）保存在程序栈中（压栈操作隐含在 CALL 指令中）。
3. 被调函数会设置帧基指针 ESP
4. 被调函数通过修改栈顶指针的值，为自己的局部变量在运行时栈中分配内存空间，并从帧基指针的位置处向低地址方向存放被调函数的局部变量和临时变量。
5. 如有必要，被调函数会保存希望调用前后保持不变的寄存器值。
6. 被调函数执行自己任务，此时可能需要访问由主调函数传入的参数。若被调函数返回一个值，该值通常保存在一个指定寄存器中 (如 EAX)。
7. 一旦被调函数完成操作，为该函数局部变量分配的栈空间将被释放。这通常是步骤 4 的逆向执行。
8. 恢复步骤 3 中保存的寄存器值，包含主调函数的帧基指针寄存器。
9. 被调函数将控制权交还主调函数 (使用 ret 指令)。根据使用的函数调用约定，该操作也可能从程序栈上清除先前传入的参数。
10. 主调函数再次获得控制权后，可能需要将先前的参数从栈上清除。在这种情况下，对栈的修改需要将帧基指针值恢复到步骤 1 之前的值。

步骤 3 与步骤 4 在函数调用之初常一同出现，统称为函数序 (prologue)；步骤 6 到步骤 8 在函数调用的最后常一同出现，统称为函数跋 (epilogue)。

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

; lab5_2.asm - Watermelonabc 2026/4/18
; 本程序用于求给定有符号数列中，绝对值比目标数 X 更大的最小负奇数
; 若存在，输出此数的绝对值；若不存在，输出 0

include Irvine32.inc

.data
TAB dword 5 dup(?)
datSize = ($ - TAB)/4
X dword 9
Min dword ?

.code

; dword _cdecl getMin(dword* src,dword goal,dword leng) [ebp+8,ebp+12,ebp+16]
; src 地址、goal 和 leng 通过堆栈传参
; 返回值通过 eax 返回，表示 Min 的绝对值

getMin PROC
    push ebp
    mov ebp,esp
    push esi
    push edx
    push ebx
    mov esi,[ebp+8]
    mov ebx,[ebp+12]
    mov ecx,[ebp+16]
    mov eax,0
    mov edx,0
    isMin:
        mov edx,[esi]
        cmp edx,0
        jge notMin ; is below 0?
        and edx,1h
        cmp edx,1
        jne notMin ; is odd number？
        mov edx,[esi]
        neg edx
        cmp edx,ebx
        jle notMin ; is bigger than X?
        cmp eax,edx
        jg notMin ; is bigger than current Min?
        mov eax,edx
        notMin:
        add esi,4
    loop isMin
    pop ebx
    pop edx
    pop esi
    pop ebp
    ret
getMin ENDP

main PROC
    mov esi,OFFSET TAB
    mov ecx,datSize
    input:
        call ReadInt ; read a signed 32 bits integer from console and put into EAX
        mov [esi],eax
        add esi,4
    loop input
    push datSize ; leng
    push X       ; goal
    push OFFSET TAB ; *src
    call getMin
    add esp,12
    mov Min,eax
    call WriteDec ; get an unsigned 32 bits integer from EAX and write to console
    exit
main ENDP

END main

9.7 局部变量

和参数不一样，局部变量是顺序 “入栈” 的。局部变量的值不是 PUSH 入栈的，而是先在栈上用 ESP 预留空间，然后直接向预留的栈空间写入局部变量。比如，一个 C 函数：

1
2
3
4
5

void MySub()
{
  int X = 10;
  int Y = 20;
}

在 x86 汇编中呈现为：

1
2
3
4
5
6
7
8
9
10

MySub PROC
push ebp
mov  ebp,esp
sub  esp,8 ; reserve space for locals in stack
mov  dword PTR [ebp-4],10 ; X
mov  dword PTR [ebp-8],20 ; Y
mov  esp,ebp ; remove locals from stack
pop  ebp
ret
MySub ENDP

栈帧大致表现为：

注意此处由于只保存了 ebp 寄存器，而它又属于栈底，因此直接将 esp 移到 ebp 就好了。如果你还使用了其他寄存器，那么还请你手动清理，再移动。

LEAVE 指令等效于清理局部变量的那两条指令。

如果是一个数组呢？同样预留空间，但是预留的空间应该符合字节对齐，宜大不宜小。并且用 LEA (Load Effective Address) 指令获取地址。OFFSET 对栈上地址没有用：

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

makeArray PROC
  push ebp
  mov  ebp,esp
  sub  esp,32
  lea  esi,[ebp-30] ; load address of myString
  mov  ecx,30
  L1:
    mov BYTE PTR [esi],'*'
    inc esi
  loop L1
  add  esp,32 ; remove the array (restore ESP)
  pop  ebp
  ret
makeArray ENDP

同样有 ENTER 和 LEAVE 指令可以为我们预留局部变量的栈空间。

ENTER 会 push EBP、设置 EBP 和 ESP 相等并减少 ESP 以预留栈空间。它有两个操作数：numbytes, nestinglevel。numbytes 是你希望预留的字节数，nestinglevel 决定了从前一帧复制到新栈帧中的栈帧指针数量。

在这里，我们将 nestinglevel 固定为 0，只修改 numbytes。

LEAVE 没有操作数，它将 ESP 设置为和 EBP 相等并弹出 EBP 以恢复栈。

而 MASM 提供了一个 ENTER 的上位替代指令：LOCAL。它更接近我们使用的参数表：

1
2
3

LOCAL temp:DWORD, SwapFlag:BYTE ; Two locals var: temp and SwapFlag
LOCAL pArray:PTR WORD ; A pointer to a 16 bits integer
LOCAL TempArray[10]:DWORD ; An array of 10 DWORD

AP. CTF 中常见汇编知识

了解了一些基本的汇编指令后，下面我们来看看 CTF 中常见的一些指令：

1. loop 循环指令：

1
2
3
4
5
6
7

mov rax,0
mov rcx,236
s:
add rax,123
loop s
leave
ret

上面的指令执行的是对 123 累加 236 次，从以上代码中我们可以看到，rcx 寄存器保存的是循环次数，loop 指令每执行一次，rcx 的数值就会减少 1，当其数值减少到 0 时，loop 指令就会停止，继续执行下面的指令。

2. 无条件跳转指令：

1
2
3
4

lable:
mov edx,0

jmp lable

无条件跳转指令为 jmp，其意思从字面上就可以看出来，只要是执行到 jmp 这里，无论什么情况，都会直接跳转到 lable 的代码块中继续往下执行指令。

3. 条件跳转：

1
2
3
4
5

lable:
mov ebx,1

cmp ebx,0
je lable

以上代码将 ebx 的值与 0 对比，如果相等，则会跳转到 lable 处，条件跳转指令 je 代表相等则跳转，还有其他与之条件不一样的条件跳转指令，一般条件跳转指令是与 cmp、test 指令混在一起用的。以上代码也可以用 test 来写：

1
2
3
4
5

lable:
mov ebx,1

test ebx,0
jnz lable

test 是逻辑与指令，以上代表的即为 ebx&0，jnz 代表标志位为 0 就跳转，其实现效果与 cmp 相同。

下面是一些常见的条件跳转指令：

下面是一些常见的位运算指令：

• AND：与运算，AND AX,BX 将 AX 与 BX 进行逻辑与运算，并将结果保存到 AX 寄存器中
• OR：或运算，OR AX,BX 将 AX 与 BX 进行逻辑或运算，并将结果保存到 AX 寄存器中
• XOR：异或运算，XOR AX,BX 将 AX 与 BX 进行异或运算，并将结果保存到 AX 寄存器中
• NOT：取反操作，NOT CX 将 CX 进行取反，并将结果保存到 CX 寄存器中
• TEST：逻辑与运算，TEST AX,BX 将 AX 与 BX 进行与运算，并设置标志位，结果不保存

4. 函数传参：

在汇编中，我们有时候需要知道参数被保存在那个寄存器里，这里我列举一般情况：

通常函数的返回值保存在 ax 寄存器里，比如 eax，rax 等； 函数的参数一般按顺序保存在 cx、dx、si 中，在 64 位汇编中，一般按 rcx, rdx, r8, r9, r10, r11, … 的顺序保存参数。

有时候根据函数调用约定以及编译器和平台的不同，这个储存规律也会发生改变，我们需要根据当时情况动态调整。

5. lea 地址加载：

其使用格式为 lea rdx,[my_var]，将 my_var 的地址而不是内容赋值给 rdx 寄存器。

6. xchg 数值交换指令：

其使用格式为 xchg ax,bx 将 ax 和 bx 的数值交换。

在广外的大学城校区比赛！体育场比 FZU 大太多了，而且貌似别的学校也有类似的规模的体育场所？！太羡慕了

被 Web 学长和 Pwn 队友带飞的一集，我这个 Re 手还是太 fw 了 QAQ

最终没有 AK 零食……

不过居然是一等奖！好欸！^-

基础数据结构

数组 (Array) 占据一块连续的内存，索引和遍历速度快 ($O(1)$)，但其他操作就慢了（插入、删除的时间复杂度是 $O(n)$），大小也不能伸缩

动态数组 (Dynamic Array) 可以随着数据量的增加而扩展（但理论上不能缩小），C++ 的 vector<T> 实现了这个数据结构。但是插入和删除依然很慢。

链表 (linked List) 基于节点 (node) 组成，在内存中一般不连续，C++ 的 list<T> 实现了这个数据结构（双向链表）。链表可以在 $O(1)$ 复杂度下实现插入和删除操作，但访问操作又退化到 $O(n)$ 了，所以很多时候也挺慢 😦

1
2
3
4
5
6

struct Node
{
int data;
Node* pNext;
Node* pPrev;
};

数组的下标只能是非负整数，而散列表 (Hash Table) 可以以任意标识访问元素，因为它是键值对 (key-value pair) 组成的。散列表的查询、插入和删除速度都很快 (理论上是 $O(1)$)。C++ 的 unordered_map<T, P> 和 unordered_set<T> 实现了这个数据结构。两者的不同在于 map 有键值对，是标准的散列表；而 set 没有，更像数学中的 “集合” 概念（既然是集合，那么 set 中的元素都是不重复的）。

注意到 “unordered” 了吗？散列表是不能排序的

先考虑最简单的情况，仅用一个数组来实现哈希表。在哈希表中，我们将数组中的每个空位称为桶 (bucket)，每个桶可存储一个键值对。因此，查询操作就是找到 key 对应的桶，并在桶中获取 value。

如何基于 key 定位对应的桶呢？这是通过散列函数 (hash function) 实现的。换句话说，我们通过散列函数为每个 key 分配（唯一的）桶位。

1
2
3
4

size_t hash(int key)
{
return key % n; // n 为桶的数量
}

散列函数本身也是有运行成本的！

使用上面的散列函数，我们很快遇到一个问题：有好几个 key 指向同一个桶位！我们称之为散列冲突 (Hash Collision)。

散列冲突的一个解决方法是链式地址 (separate chaining)。我们将冲突的键值对通过链表（有时也用 vector<T>）连接起来，输入 key 后先遍历桶，再遍历桶下的冲突链。

队列 (Queue) 和栈 (Stack) 都是关于 push（推入）和 pop（弹出）的数组 / 队列，区别在于队列是先进先出 (FIFO) 的，栈是后进先出 (LIFO) 的。C++ 分别用 queue<T> 和 stack<T> 实现

二叉树 (Binary Tree) 是一个树状数据结构，用于快速搜索、插入和删除。它经常作为散列表的替代，速度稍慢 ($O(\log{N})$)，但使用时是排序好的

堆 (Heap) 是一种二叉树的特例，用数组实现，常用于优先队列 (priority queue)

实践部分

有些算法和数据结构可以直接用标准库的，毕竟这篇是 “功利性质” 的，就没有重复造轮子的必要了。

注意 “数据保证 XX”，这说明我们不需要考虑判断输入的数据是否符合 XX 条件，因为已经保证它符合这个 XX 条件了（系统不会在酒吧里点炒饭的）

考 FZU DS 原题，分为栈、队列、排序、二叉搜索树以及图和路径

CPP “万能” 文件头：<bits/stdc++.h>

下面是 DS 题目与配套的 AC 代码（感谢 LuminaryDawn 整理提供 😃）

另附 .pbs 文件，你可以导入小熊猫 C++ 实现本地自动判题：FZU DS.pbs

如果你想 “背诵”，建议背关键算法的描述，除非你认为自己真的能像背课文那样把一行行代码背下来

实际考试为了降低难度，较简单题的分数是比较高的。
注意 PTA 的补全提示很少，复习时不要依赖 IDE 的补全
如果想通过，总分应该在 50 分以上

表

亚克星上的军队

★实验任务

亚克星上住着许多神奇的生物。其中有聪慧的人族、优雅的精灵、彪悍的野蛮猪、粗鲁的首任驻….有一天，住在湛蓝球上的恶魔们突破空间的封锁入侵这个美丽的星球。为了保卫共同的家园，亚克星各族不得不摒弃前嫌，组成联盟。为了更有利的反击恶魔们的入侵，他们建立了统一的军事指挥中心。在前期，指挥中心会不停的发布军队调动命令，可是，麻烦来了。为了更好的做出决策，指挥中心必须迅速了解己方的各地区的军事力量详情。你能否帮帮这些可怜的种族呢？

每个地区有一个编号（从 1 到 N），如果一个地区有军队的话，这些军队将组成一个军团。指挥中心将发布的命令如下：

U a b:将 b 地区军团的调到 a 地区，从而组成一个新的军团。为了便于管理，每次新加入的军队将按顺序加入到 a 军团后面。数据保证 a 与 b 不相同。

I a x:将一支人数为 x 的军队调到 a 地区。为了便于管理，每次新加入的军队将加入到 a 军团前面。

D a x:将 a 地区中军队人数为 x 的调走。若不存在，则不执行。

Q a：询问 a 地区的具体军事信息（即按顺序输出该军团中每个军队的人数）。

★数据输入

输入第一行为两个正整数 N ,M (2 <= N,M <= 1000)。

接下来 N 行，每行第一个数 K 表示该地区军队的个数 K (1<=K<=100)，接下来 K 个数, 表示各个军队的人数信息 (0<=a_i < 2^31)。

接下来 M 行，每行一个操作。

★数据输出

对于每个询问操作，输出一行表示 a 地区具体军事信息，每两个数之间空格隔开，行末无空格。若 a 内无元素，输出 - 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

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

int main() {
// 基于流的 I/O 优化
// std::cin.tie(nullptr); // 解除关联
// std::ios::sync_with_stdio(false); // 关闭同步

ll n,m; // n: 区域数；m: 操作数
cin >> n >> m;

vector<list<ll>> listt(n); // 存储各区域的军事信息

for (ll i = 0; i < n; i++) {
ll t;
cin >> t; // t: 军队个数
for (ll j = 0; j < t; j++) {
ll temp;
cin >> temp; // temp: 各军队人数
listt[i].push_back(temp);
}
}

for (ll i = 0; i < m; i++) {
char type;
cin >> type;

if (type == 'U') {
ll a,b;
cin >> a >> b;
a--;
b--; // 编号从 1 到 N，减 1 和数组下标对齐
listt[a].splice(listt[a].end(), listt[b]); // splice(a, b) 将 b 的内容转移到 this*，位置为 a
}
else if (type == 'I') {
ll a,x;
cin >> a >> x;
a--;
listt[a].push_front(x); // list 的向前插入
}
else if (type == 'D') {
ll a,x;
cin >> a >> x;
a--;
listt[a].remove(x); // remove() 移除符合特定条件的元素
}
else if (type == 'Q') {
ll y;
cin >> y;
y--;

if (listt[y].empty()) {
cout << "-1\n";
}
else {
bool first = true;
for (auto j : listt[y]) {
if (!first) cout << " ";
cout << j;
first = false;
}
cout << "\n";
}
}
}

return 0;
}

洗盘子

★实验任务

猪妈妈有很多小猪仔，每次吃完饭洗盘子是一个很大的问题。这天猪妈妈想出了一个方法。她让小猪们排成一队，从 2 开始给他们编号。每次排在最前面的不用洗盘子（假设它的编号是 i ），但是，排在它后面的第 i 只 ，2 i 只，3 i 只… 的小猪要洗盘子。让排在最前面以及要洗盘子的小猪出队，然后重复上述过程。那些不用洗盘子的小猪被称为幸运猪（lucky pigs），把它们的编号从小到大排序，现在要问第 n 个幸运猪的编号是多少。

比如说一开始，在最前面的小猪编号是 2，那么它不用洗盘子，出队。在它后面的第 2 只小猪，就是编号为 4 的小猪要洗盘子，编号为 6, 8, 10… 的小猪都要洗盘子，然后它们都出队。其中编号为 2 的小猪就是第一只幸运猪了。接下排在最前面的小猪编号是 3，它是幸运猪，出队。在它后面的第 3 只，就是编号为 9 的小猪要洗盘子，出队。以此类推。

★数据输入

输入第一行为 T ，代表接下去有 T 个询问， 0 < T <=300

接下去有 T 行，每行一个数 n ，0 < n <=3000

★数据输出

对于每个询问输出一行，为第 n 个幸运猪的编号。

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

#include <iostream>
#include <vector>

using namespace std;

int main() {
int T;
cin >> T;

vector<int> luckyPigs;
vector<int> pigs;

for (int i = 2; i <= 100000; i++) {
pigs.push_back(i); // 初始化猪仔编号向量
}

while (luckyPigs.size() < 3000 && !pigs.empty()) { // 限制求解规模
int lucky = pigs[0]; // 每次排在最前面的不用洗盘子
luckyPigs.push_back(lucky); // 编号推入 luckyPigs 向量

vector<int> keep; // 没被叫去洗盘子

for (int j = 1; j < pigs.size(); j++) {
if ((j % lucky) != 0) {
keep.push_back(pigs[j]);
}
}

pigs = keep;
}

while (T--) {
int n;
cin >> n;
cout << luckyPigs[n - 1] << endl;
}

return 0;
}

队列

Rescue the princess

★实验任务

有一天，公主被一个魔王抓走关在一个城堡里面，城堡可以用 N * M 的矩阵来描述，1 < N, M <= 200。监狱由 N * M 个方格组成，每个方格中可能为墙壁，空地，怪物，公主或者是勇士。

现在勇士想去营救公主。他的任务是找到公主。约定，“找到公主” 的意思是到达公主被关的位置。如果勇士想到达某个方格，但方格中有怪物，那么必须杀死怪物，才能到达这个方格。假设勇士只能向上，下，左，右四个方向移动一步。移动一步的需要花费 1 个单位的时间，杀死怪物也需要一个单位的时间。

试着计算勇士找到公主需要多长时间。只能上，下，左，右移动，而且墙壁不能通过。

★数据输入

输入第一行包含 2 个整数 N，M，接下来 N 行，每行 M 个字符：. 代表空地，a” 表示公主，r 表示勇士， # 代表墙壁， x 表示怪物。（测试数据中 a 和 r 只有一个）。

★数据输出

输出一个整数，表示找到公主所需要最短的时间。如果无法找到公主，输出 - 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#include <bits/stdc++.h>

using namespace std;

struct Node {
int x, y, time;
// 重载大于运算符，比较两个 Node 等价于比较两个 Node.time
bool operator>(const Node& other) const {
return time > other.time;
}
};

int main()
{
int n, m;
cin >> n >> m;
vector<string> grid(n);
int start_x=-1, start_y =-1, end_x=-1, end_y=-1;

// 读入地图，初始化坐标
for(int i=0;i< n;i++){
cin >> grid[i];
for(int j=0;j<m;j++){
if(grid[i][j] == 'r'){
start_x = i;
start_y = j;
}
if(grid[i][j] == 'a'){
end_x = i;
end_y = j;
}
}
}

// 方向向量，表示移动方式
int dx[4] = {0, 0, 1, -1}; // 上：-1，下：1
int dy[4] = {1, -1, 0, 0}; // 左：-1，右：1

// 每个格子相对于起点的路径距离（时间成本），初始化为“无穷大”
vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
dist[start_x][start_y] = 0;

// 定义最小堆，堆顶元素必定最小。great 表示大于队尾元素的插入元素进入队尾，否则插入队尾元素之前。最大堆用 less
    // 存储待探索的点，按距离升序排序
priority_queue<Node, vector<Node>, greater<Node>> pq;

// 起点作为第一个待探索点
pq.push({start_x, start_y, 0});

while(!pq.empty())
{
Node curr = pq.top(); // 当前位置
pq.pop(); // 将该点弹出待探索堆。之后此点不再探索
int x = curr.x;
int y = curr.y;
int time = curr.time;
        // 剪枝。这说明你是从较远路径来到这个点的，而根据我们的走法，已经有“人”探索接下来的路了，因此不要重复探索。
if(time > dist[x][y]){
continue;
}
// 向 4 个方向探索
for(int i=0;i<4;i++){
int nx = x + dx[i];
int ny = y + dy[i];
// 探测边界和墙壁
if(nx < 0 || nx >= n || ny < 0 || ny > m || grid[nx][ny] == '#'){
continue;
}
int new_time = time + 1; // 前进 1 步
// 遇怪增加时间
if(grid[nx][ny] == 'x'){
new_time ++;
}
// 如果找到更短路径，则更新路径距离
if(new_time < dist[nx][ny]){
dist[nx][ny] = new_time;
pq.push({nx, ny, new_time}); // 把点推入待探索堆中
}
}
}
if(dist[end_x][end_y] != INT_MAX){
cout << dist[end_x][end_y] << "\n";
}
else
{
cout << "-1" << "\n";
}
}

交易

考了

★实验任务

作为炉石传说的发牌员，你的任务就是发牌。从上到下有 n 张牌，编号 1~n。因为你和选手进行了一次 “交易”，所以当至少还剩两张牌时，发出最上面的牌，第二张牌放到最下面，重复这个过程直到只剩下一张牌。输出发牌的序列和最后剩下的牌。

★数据输入

第一行 1 个正整数 n (1=<n < 1000)

★数据输出

输出一行为发牌的序列，一行为最后剩下的牌。两个数字之间用空格隔开，末尾没有空格。

★Hint

第一个样例 n = 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
34

#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
queue<int> card;
    // 初始化牌堆
for(int i=1;i<=n;i++){
card.push(i);
}
bool isFirst = true;
do
{
if(!isFirst){
cout << " ";
}
        // 输出第一张牌
cout << card.front();
card.pop();
isFirst = false;
        // 第二张牌排到队尾
if(!card.empty()){
int second = card.front();
card.pop();
card.push(second);
}
}
while(card.size() >= 2);
cout << endl;
if(!card.empty()){
cout << card.front();
}
}

栈

火车

考了

★实验任务

TonyY 等火车无聊的时候，会去观察火车的排列，有一天他思考这么一个问题，火车总站的火车只能进站，要出站的话只能先出最后进站的那辆车，那么知道火车的进站顺序，能不能把它的出站顺序调整成火车站想要的呢？

★数据输入

输入第一行为一个正整数 n 表示火车辆数 (编号 1-n)（1<=n<=9）。

然后为两个长度为 n 的序列，表示火车的进站顺序和出站顺序。每辆火车刚好进出站各一次。

★数据输出

如果可以调整，输出 Yes 和出入站顺序。

如果不能，输出 No。

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

#include <iostream>
#include <stack>
#include <string>
using namespace std;

int main() {
int n;
cin >> n;

string in_seq, out_seq;
cin >> in_seq >> out_seq;

stack<int> station;
int out_index = 0;  // 当前应该出站的元素索引
bool possible = true;

// 模拟过程判断是否可能，并记录操作序列
string operations[20]; // 最多 2 * 9 = 18 次操作
int op_count = 0;

for (int i = 0; i < n; i++) { // 由于出入站是单行的，因此每列列车有且只有一次进站和出站操作
// 入站
station.push(in_seq[i] - '0');
operations[op_count++] = "in";

// 检查能否出站，while 应对连续出站情况
while (!station.empty() && station.top() == out_seq[out_index] - '0') {
station.pop();
operations[op_count++] = "out";
out_index++;
}
}

// 检查是否所有元素都正确出栈
if (out_index != n) {
possible = false;
}

if (possible) {
cout << "Yes" << endl;
// 输出缓存的操作序列
for (int i = 0; i < op_count; i++) {
cout << operations[i] << endl;
}
} else {
cout << "No" << endl;
}

return 0;
}

价值

★实验任务

K 神最近喜欢上了刷题，一天不刷浑身难受。最近他研究发现，自己的人生价值在于他某段时间内的刷题总数乘上这几天刷题数的最小值，现在 K 神很寂寞（无敌是多么寂寞），想知道他人生价值最高的时候究竟有多高（krz）

★数据输入

第一行为总天数 N (1<=N<=100000)

接下来一行 N 个整数 ai（1<=ai<=100000），表示 K 神第 i 天的刷题数。

★数据输出

输出 K 神在连续一段时间内可能的最高价值 W。

对每个元素 a[i]，把它当作 “区间最小值”，看它能控制的最大区间，然后计算 a[i] * (这个区间的元素和)，取最大值。

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
51
52
53

#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int num=n+5;
vector<int>a(num), left(num), right(num);
for(int i=1;i<=n;i++){
cin>>a[i];
}

// 求前缀和，便于求区间和，例如区间 [a,b) 内的和为 sums[b-1] - sums[a]
vector<long long>sums(n+1,0);
for(int i=1;i<=n;i++){
sums[i]=sums[i-1]+a[i];
}

// 求区间和就需要求上下边界
    // 将刷题数序列的每一个值都认为是属于某个区间的最小值，现在就是求最大的区间。

    // 使用单调栈排序下标
stack<int>st;

    // 左边界，从左到右选择
for(int i=1;i<=n;i++){
        // 如果当前栈顶的元素不小于要插入的元素，则弹出栈顶元素。注意一定要带等号，不然会出错
while(!st.empty() && a[st.top()]>=a[i]){
st.pop();
}
left[i]=st.empty()?0:st.top();
st.push(i);
}
    // 清空栈
while(!st.empty())
st.pop();
    // 右边界，从右到左选择
for(int i=n;i>=1;i--){
        // 如果当前栈顶的元素小于要插入的元素，则弹出栈顶元素
while(!st.empty() && a[st.top()]>a[i]){
st.pop();
}
right[i]=st.empty()?(n+1):st.top();
st.push(i);
}
long long maxx=0;
for(int i=1;i<=n;i++){
long long sum=sums[right[i]-1]-sums[left[i]];
long long cur=a[i]*sum;
maxx=max(maxx, cur);
}
cout<<maxx<<endl;
return 0;
}

排序与选择

魔音吉他

考了

★问题描述

少年甲很喜欢音乐，有一天他来到了少年乙的村落。少年甲一曲高山流水，寻觅到了乙这位知音。然而，天下没有不散的宴席，少年甲要回村杀猪了，离别在即，少年乙拿出了自己珍藏多年的吉他，作为离别的礼物。就在少年甲欣喜之际，少年乙说，这把吉他变幻莫测，每次你拿起它的时候，它会有 n 根弦，每根弦可以演奏出$10^{18}+1$ 个音符，而这$10^{18}+1$ 个音符是连续的，取决于它每根弦的第一个音符（请看样例说明）。
此时，少年甲提出了一个疑问，如果给定一个区间 l，r（包括端点），里面共有几种不同的音符呢？少年乙对此谙熟于心，但是他想考验一下你，于是将这个问题抛给了你。

★数据输入

第一行一个正整数 n (1<=n<=100,000)，表示吉他有几根弦。
第二行共 n 个数 x，即代表对应弦的第一个音符 (0<=x<=$10^{18}$)。
第三行一个正整数 q (1<=q<=100,000)，表示少年甲的询问次数。
接下来 q 行，每行两个数 l，r (0<=l, r<=$10^{18}+1$)，表示少年甲想要询问的区间。

★数据输出

输出共 q 个数，表示对应 q 个询问的答案。即询问区间内有多少个不同的音符。以空格隔开。

★样例说明

对应弦的第一个音符：3 1 4 1 5 9

列下标：0 1 2 3 4 5 ……
弦一： 3 4 5 6 7 8 ……
弦二： 1 2 3 4 5 6 ……
弦三： 4 5 6 7 8 9 ……
弦四： 1 2 3 4 5 6 ……
弦五： 5 6 7 8 9 10 ……
弦六： 9 10 11 12 13 14 ……

在第一根弦（最低音为 1）遇到的音符为 1、2、3，一共 3 个新音符。
在第二根弦（最低音为 3）遇到的音符为 3、4、5，一共 2 个新音符。
在第三根弦（最低音为 4）遇到的音符为 4、5、6，一共 1 个新音符。
在第四根弦（最低音为 5）遇到的音符为 5、6、7，一共 1 个新音符。
在第五根弦（最低音为 9）遇到的音符为 9、10、11，一共 3 个新音符。
区间 [0,2] 内有 1、2、3、4、5、6、7、9、10、11，共 10 个不同的音符。

★Hint

（1）询问区间 l，r 即为样例说明中的列下标。
（2）所谓不同音符个数，即区间 l，r 内 n 行内不同的数字个数。
（3）由于 l，r 的范围巨大，请思考其与每行第一个数字的关系（即给出的第一个音符）。

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

// 由“样例说明”可知，从第二根弦开始每根弦遇到的新音符数量受其与上一跟弦的差值影响即 a[i] - a[i-1]（比如 a[2] - a[1] = 3 - 1 =2, a[3] - a[2] = 4 - 3 = 1)，但如果其差值大于询问的区间长度 (r-l+1)，其增长的值就为其区间范围的值
// 则总的音符数为基弦的音符数（区间长度）+ 后面弦的新增音符数

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

int main() {
    int n;
    cin >> n;
    vector<long long> first(n);
    for (int i = 0; i < n; i++) {
        cin >> first[i];
    }
    //把弦的起始音符排个序
    sort(first.begin(), first.end());
    //求出相邻弦之间的差值
    vector<long long> diff;
    for (int i = 1; i < n; i++) {
        diff.push_back(first[i] - first[i - 1]);
    }
    sort(diff.begin(), diff.end());
    //计算前缀和（为了后面快速求和）
    vector<long long> pre(diff.size() + 1, 0);
    for (int i = 0; i < (int)diff.size(); i++) {
        pre[i + 1] = pre[i] + diff[i];
    }
    int q;
    cin >> q;
    for (int t = 0; t < q; t++) {
        long long l, r;
        cin >> l >> r;
        // 区间长度（包括两端）
        long long len = (r >= l) ? (r - l + 1) : 0;
        // 找出 <= len 的差值数量
        int k=upper_bound(diff.begin(),diff.end(),len)-diff.begin();
        // 计算 sum(min(len, diff[i]))
        long long summin = pre[k] + (long long)(diff.size() - k) * len;
        // 最终结果（音符总数）
        long long ans = len + summin;
        cout << ans; // 输出
        if (t != q - 1) cout << " ";
    }
    cout << endl;
    return 0;
}

Just Sort

★实验任务

给定两个序列 a, b，序列 a 原先是一个单调递增的正数序列，但是由于某些原因，使得序列乱序了，并且一些数丢失了（用 0 表示）。经过数据恢复后，找到了正数序列 b ，且序列 a 中 0 的个数等于序列 b 的个数，打算使用序列 b 恢复序列 a。

对于序列 a 来说，我们可以交换两个位置上的非零的数，并且可以交换任意次。序列 b 同样也可以进行任意次交换。

现在要将序列 b 填充到序列 a 中的值丢失的位置上，序列 b 中的每个数只能填充一次，问最后构成的序列是否是单调递增的，如果是，则输出填充后的序列，否则输出 - 1。

★数据输入

输入给定 N, M，表示序列 a 和序列 b 的长度。

第一行为序列 a，第二行为序列 b。题目保证除了 0 以外的数，在序列 a 和 b 中只出现一次。

数据保证:

80% 的数据，N, M <= 100

100% 的数据，N, M <= 100000, 0 <= a [i] <= 100000, 0 < b [i] <= 100000

★数据输出

如果最后序列 a 是单调递增的，输出该序列，否则输出 -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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;
int a[N], b[N], c[N], vis[N];

void solve()
{
int n, m;
cin >> n >> m;
int idx = 0;
for(int i=1;i<=n;i++){
int x;
cin >> x;
if(x==0){
vis[i] = 1; // 标记序列 a 中缺失元素的位置
}
else
{
a[++idx] = x; // 收集 a 中非 0 的数
}
}
for(int i = 1; i <= m; i++)
{
cin >> b[i];
}
    // 允许任意交换意味着原始位置已经不重要了，只剩下“数的集合”重要
    // 问题变成：能否把“a 的非零数和 b 中的数”重新排列，按原位置规则放回（形成新序列），使整个序列严格递增？
sort(a + 1, a + idx + 1); // std::sort(container.begin(), container.end());
sort(b + 1, b + m + 1);
int idx1 = 0, idx2 = 0;
for(int i=1;i<=n;i++){
if(vis[i]){
c[i] = b[++idx1]; // 如果此位置是 a 中缺失的元素位置，那么用序列 b 填充
}
else
{
c[i] = a[++idx2]; // 如果没缺失，则用 a 中原本没缺失的元素填充
}

if(i > 1){
            // 发现填充违规，说明当前最小可用的数都不够大，而换用更大的数会把这个较小数留给后面更大的数，更难实现递增
if(c[i] <= c[i - 1]){
cout << "-1" << "\n";
return;
}
}
}
for(int i=1;i<=n;i++){
if(i != 1){
cout << " ";
}
cout << c[i];
}
cout << "\n";
}

int main()
{
solve();
}