湖南大学 on cyp0633's Blog

HNU 软件编译原理实验 4（Go 实现）

Sat, 06 May 2023 00:00:00 +0000

编译器、解释器、虚拟机，或许只在杨氏编译原理里面是同义词。

代码已上传至GitHub，为防止篇幅过长，没有内置所有代码，仅对个人认为值得讲述的地方进行说明，可以对比阅读。

TINY语言编译器的部分到了中间代码生成部分就结束了，生成的是下面这样的TM虚拟机机器码，剩下的部分一直到运行，都由虚拟机来完成。

text

  0:     LD  6,0(0) 
  1:     ST  0,0(0) 
  2:     IN  0,0,0 
  3:     ST  0,0(5) 
  4:    LDC  0,0(0) 
  5:     ST  0,0(6)

在实验三中完成了词法分析器，实验四包括了语义分析和中间代码生成，至于指导书没提的语法分析，当然只能自己加上了。

TINY编译器的C代码中，大致流程为：词法分析（scan.c）-> 语法分析（parse.c）-> 语义分析（analyze.c）-> 中间代码生成（code.c、cgen.c）。另外还有符号表管理（symtab.c）。本文的之后部分中，将其改写 + 优化为Go代码进行解释。

该编译器不含有独立的错误处理模块，错误处理在各模块中解决。

语法分析

该编译器的语法分析输出是一个语法树，树节点用以下的结构描述。

type treeNode struct {
    child   [3]*treeNode // 子节点
    sibling *treeNode    // 兄弟节点
    lineNo  int          // 行号
    op      tokenType    // 操作符
    val     int          // 值
    attr    string       // 属性
    stmt    stmtKind     // 语句类型
    expr    exprKind     // 表达式类型
    typ     exprType     // 表达式数值类型
    node    nodeKind     // 节点类型
}

命名很乱是吧，我也是这么想的。

节点类型 nodeKind 分为表达式节点和语句节点，前者对应一个表达式（如1+1），后者对应一整个或一行语句（如 write i）
语句类型 stmtKind 分为赋值、循环、条件分支、读、写几种
表达式类型 exprKind 是当前表达式节点的类型，分为运算符、常量、标识符变量
表达式值类型 exprType 分为整型表达式、布尔表达式和没有值的表达式（真的存在吗）

由于Go孱弱的类型系统，既没有泛型多态有没有类似Rust的Trait（巧了，C也没有），所以每个节点存储完整的信息，不会因表达式或是语句节点而使用不同的结构体。

对于一个 treeNode，同一个节点的某个child的sibling和其他child并不是并列的关系。对于某个语句节点，sibling指向的是下一个语句，例如：

text

1
2

fact := fact * x; 
x := x - 1;

第二句作为一个赋值语句节点，就是第一句的sibling。而child可以视为语句中的 “槽位”，如：

text

1
2
3

if 0 < x then
    fact := 1;
end

上面的 if-then-end 语句有两个槽，分别存放 0 < x 表达式节点和 fact := 1 语句节点，也就是这个条件分支语句节点的两个child。因为槽最多的就是 if-then-else-end，有三个，所以child最大也仅需要三个。

Parse 函数用来启动语法分析，返回语法树根节点。它调用 stmtSequence() 函数，期望其返回时分析完整个源代码，如果最后识别到的token不为eof，则文件中含有错误。

func Parse() (t *treeNode) {
    currToken= GetToken()
    t = stmtSequence()
    if currToken != eofToken {
        syntaxError("Code ends before file\n")
    }
    return
}

stmtSequence 函数用来识别位于同一作用域（如同一if-clause，也就是Python中同一缩进等级）的一串语句，当找到eof、end、else 和 until 这几个代表结束的词语时结束。

t为nil这一个分支我也没看懂为什么在这里。

func stmtSequence() *treeNode {
    t := statement()
    p := t
    for currToken != eofToken && currToken != endToken && currToken != elseToken && currToken != untilToken {
        match(semicolonToken)
        q := statement()
        if q != nil {
            if t == nil {
                p = q
                t = p
            } else {
                p.sibling = q
                p = q
            }
        }
    }
    return t
}

statement 函数好理解，一次识别单个语句，根据识别出的token类型进入不同的识别函数。代码略。

各种不同语句的识别函数分为if、repeat、赋值语句、read和write，此处只以 ifStatement 为例，其他看看代码应该就明白了。if节点的三个域分别存放expression（条件检验表达式）、then-statement（符合执行的语句串）和else-statement（不符合执行的语句串）。

// if 语句的匹配
//
// if <expression> then <stmtSequence> [else <stmtSequence>] end
func ifStatement() *treeNode {
    t := newStatementNode(ifStmt)
    match(ifToken)
    t.child[0] = expression()
    match(thenToken)
    t.child[1] = stmtSequence()
    if currToken == elseToken {
        match(elseToken)
        t.child[2] = stmtSequence()
    }
    match(endToken)
    return t
}

语句的匹配在上面就结束了，而表达式的匹配需要考虑优先级问题。在这个编译器程序中，分为三个优先级：< 和 = 优先级最低，+ 和 - 优先级次之，* 和 / 更高，数字、标识符和括号则设为同一最高优先级。在形式化语言表示中，使用不同的符号（Expression、Term、Factor）区分不同的计算优先级。产生式有：

$Expression \to simpleExpression\ |\ simpleExpression \lt simpleExpression\ |\ simpleExpression \lt \simpleExpression$

$simpleExpression \to Term\ |\ Term+Term\ |\ Term-Term$

$Term \to Factor\ |\ Factor \times Factor\ |\ Factor / Factor$

仅贴出Expression的代码，其他类似。

// 表达式的匹配：处理 < 和 = 运算符
// 优先级最低
func expression() *treeNode {
    t := simpleExpression()
    if currToken == ltToken || currToken == eqToken {
        p := newExpressionNode(opExpr)
        p.child[0] = t
        p.op = currToken
        t = p
        match(currToken)
        t.child[1] = simpleExpression()
    }
    return t
}

数字和标识符的处理（factor）如下：

// 表达式的匹配：处理数字、标识符和括号
func factor() (t *treeNode) {
    switch currToken {
    case numToken:
        t = newExpressionNode(constExpr)
        if currToken == numToken {
            var err error
            t.val, err = strconv.Atoi(tokenString)
            if err != nil {
                syntaxError("unexpected token -> %s"+ currToken.String())
            }
            match(numToken)
        }
    case idToken:
        t = newExpressionNode(idExpr)
        if currToken == idToken {
            t.attr = tokenString
        }
        match(idToken)
    case lparenToken:
        match(lparenToken)
        t = expression()
        match(rparenToken)
    default:
        syntaxError("unexpected token -> %s"+ currToken.String())
        currToken = GetToken()
    }
    return
}

符号表

原来的C版本编译器说白了也就是个自定义哈希函数的哈希表，是一个数组实现，封装了查找和插入，所以既然Go本身就有无序的字典 map，当然就用上了。

符号表项的键为符号名，值为内存地址（从0起）和出现的行数列表 的引用。

var symtab map[string]*struct {
    refLines []int // 引用行号列表
    memLoc   int   // 内存位置
} = make(map[string]*struct {
    refLines []int
    memLoc   int
})

在原来的符号表实现中，新符号的地址是由词法分析器决定的（而且是简单的递增），此处由符号表模块自行管理。

查找很简单，判断是否存在罢了。

// 查找符号表
// 返回内存位置和是否找到
func lookupSymtab(name string) (location int, ok bool) {
    if item, ok := symtab[name]; ok {
        return item.memLoc, true
    }
    return 0, false
}

插入分两种情况，如果已经存在，则仅更新行数列表；否则，还要分配一个空间。要改变map中某个元素的值，需要将其取出、修改值，然后重新设立对应关系，所以在上面的定义中使用了引用，得以在不修改引用地址的情况下增加引用行列表。

func insertSymtab(name string, lineNo int) {
    if item, ok := symtab[name]; ok {
        item.refLines = append(item.refLines, lineNo)
    } else {
        symtab[name] = &struct {
            refLines []int
            memLoc   int
        }{[]int{lineNo}, memLoc}
        memLoc++
    }
}

语义分析

语义分析主要干两件事，类型检查和插入符号表。

定义了一个统一的DFS函数，通过传入不同的函数，执行前序和后序遍历的操作。类型检查需要后序遍历，插入符号表则需要前序遍历（看起来TINY是 lexical scoping）。

func traverse(t *treeNode, preProc func(*treeNode), postProc func(*treeNode)) {
    if t == nil {
        return
    }
    if preProc != nil {
        preProc(t)
    }
    for i := 0; i < 3; i++ {
        traverse(t.child[i], preProc, postProc)
    }
    if postProc != nil {
        postProc(t)
    }
    traverse(t.sibling, preProc, postProc)
}

构建符号表需要对每个出现变量的地方都进行一次插入操作。因为在之前的符号表操作中已经做到了根据已经插入与否区分不同的行为，所以此处可以省去判断是否已经存在。

// 将某个语法树节点的信息插入符号表
func insertNode(t *treeNode) {
    switch t.node {
    case stmtNode: // 对于语句，只有赋值和读语句需要插入符号表
        if t.stmt == assignStmt || t.stmt == readStmt {
            insertSymtab(t.attr, t.lineNo)
        }
    case exprNode: // 对于表达式，其中的标识符都要记在符号表中
        if t.expr == idExpr {
            insertSymtab(t.attr, t.lineNo)
        }
    }
}

// 遍历，构建符号表
func BuildSymtab(t *treeNode) {
    traverse(t, insertNode, nil)
}

类型检查的思想就是，赋值语句和写语句后面要匹配integer类型，if和repeat则要匹配bool类型。

// 对 t 做类型检查，反正就 bool 和 integer 两种类型
func checkNode(t *treeNode) {
    switch t.node {
    case exprNode:
        switch t.expr {
        case opExpr: // 运算符表达式，两个 child 类型均为 integer
            if t.child[0].typ != intExpr || t.child[1].typ != intExpr {
                typeError(t,"Op applied to non-integer")
            }
            if t.op == eqToken || t.op == ltToken { // 返回的是比较结果
                t.typ = boolExpr
            } else { // 返回的是计算结果
                t.typ = intExpr
            }
        default: // const 或 id，直接返回类型
            t.typ = intExpr
        }
    case stmtNode:
        switch t.stmt {
        case ifStmt: // if 语句，条件表达式类型为 bool
            if t.child[0].typ != boolExpr {
                typeError(t.child[0], "If test is not Boolean")
            }
        case assignStmt: // 赋值语句，表达式类型为 integer
            if t.child[0].typ != intExpr {
                typeError(t.child[0], "Assignment of non-integer value")
            }
        case writeStmt: // 写语句，表达式类型为 integer
            if t.child[0].typ != intExpr {
                typeError(t.child[0], "Write of non-integer value")
            }
        case repeatStmt: // repeat 语句，条件表达式类型为 bool
            if t.child[1].typ != boolExpr {
                typeError(t.child[1], "Repeat test is not Boolean")
            }
        }
    }
}

// 对整个语法树做类型检查
// 在进行完毕类型推导后，再做节点类型检查
func TypeCheck(t *treeNode) {
    traverse(t, nil, checkNode)
}

代码生成

生成代码已经是这个编译器做的最后一步了，没有优化，没有中间代码。TM虚拟机读取的还不完全是三地址码，更别提LLVM IR那样高阶的东西了，而是有点类似于真实计算机的寄存器 + 内存的组合。寄存器有累加AC1和AC2、程序计数器PC，以及GP和MP寄存器。

在 codegen.go 中，使用 CodeGen() 初始化程序运行环境，调用 cGen 对AST根节点生成代码，然后挂起虚拟机。在 cGen 中，根据当前节点的类型调用 genStmt 或 genExp 生成语句或表达式，然后再对其兄弟节点调用 cGen，生成下一条语句对应的代码。

语句

对于 repeat <statement> until <expression>，先执行statement，再判断expression，判断结果会存放在AC1寄存器中。当AC1为0时代表条件成立，执行条件跳转指令，到statement之前，再次执行。

    case repeatStmt:
        emitComment("-> repeat")
        p1 := t.child[0]
        p2 := t.child[1]
        // 保存循环前的位置
        savedLoc1 := emitSkip(0)
        emitComment("repeat: jump after body comes back here")
        // 执行语句
        cGen(p1)
        // 判断条件
        cGen(p2)
        // 如果符合，跳转到 savedLoc1，即循环前
        emitAbsRM("JEQ", ACCUMULATOR1, savedLoc1)
        emitComment("<- repeat")

对于 if 语句，依次填入的指令为：

判断 expr
若不符合，跳转到 stmt2
执行 stmt1
跳转到 stmt2 结束
执行 stmt2

    case ifStmt:
        // if <expr> then <stmt1> else <stmt2> end
        // 或 if <expr> then <stmt1> end
        emitComment("-> if")
        p1 := t.child[0]
        p2 := t.child[1]
        p3 := t.child[2]
        // 生成条件表达式的代码
        cGen(p1)
        // 空一个跳转 stmt1 末尾的位置
        savedLoc1 := emitSkip(1)
        emitComment("if: jump to else belongs here")
        // 生成 stmt1 的代码
        cGen(p2)
        // 空一个指令，供跳转到 stmt2 结束
        savedLoc2 := emitSkip(1)
        emitComment("if: jump to end belongs here")
        // 获得 stmt2 的开始位置
        currLoc := emitSkip(0)
        // 回到 expr 判断结束处，写入条件跳转语句
        emitBackup(savedLoc1)
        emitAbsRM("JEQ", ACCUMULATOR1, currLoc)
        emitComment("if: jmp to else")
        // 回到 stmt2 开始处
        emitRestore()
        // 生成 stmt2 语句的代码
        cGen(p3)
        // 获得 stmt2 结束后的位置
        currLoc = emitSkip(0)
        // 回到 stmt1 结束处，无条件跳转到 stmt2 结束处
        emitBackup(savedLoc2)
        emitAbsRM("LDA", PROGRAM_COUNTER, currLoc)
        emitComment("if: jmp to end")
        // 回到 stmt2 结束处
        emitRestore()
        emitComment("<- if")

对于 assign 语句，就是计算表达式的值，查符号表得到内存地址，然后将值存进去：

    case assignStmt:
        // <id> := <expr>
        emitComment("-> assign")
        // 计算表达式的值，存入 ACCUMULATOR1
        cGen(t.child[0])
        // 找到 id 的内存偏移
        loc, _ := lookupSymtab(t.attr)
        // 将表达式的值存入 id 的内存偏移
        emitRM("ST", ACCUMULATOR1, loc, GLOBAL_POINTER)
        emitComment("<- assign")

read 和 write 语句也会使用AC1作为中转，不同的是 write 计算表达式的值时会隐式地存入AC1，表现倒是相同的：

    case readStmt:
        // read <id>
        emitComment("-> read")
        // 读取输入，存入 ACCUMULATOR1
        emitRO("IN", ACCUMULATOR1, 0, 0)
        loc, _ := lookupSymtab(t.attr)
        // 将输入的值存入 id 的内存偏移
        emitRM("ST", ACCUMULATOR1, loc, GLOBAL_POINTER)
        emitComment("<- read")
    case writeStmt:
        emitComment("-> write")
        // 计算表达式的值，存入 ACCUMULATOR1
        cGen(t.child[0])
        // 将 ACCUMULATOR1 的值输出
        emitRO("OUT", ACCUMULATOR1, 0, 0)
        emitComment("<- write")

表达式

此处每个表达式的结果最后都会存放在AC1寄存器中，这是一个约定用法。

常量表达式最简单，直接使用加载常量的指令，把值存入AC1：

    case constExpr:
        emitComment("-> Const")
        // 将常量存入 ACCUMULATOR1
        emitRM("LDC", ACCUMULATOR1, t.val, 0)
        emitComment("load const")
        emitComment("<- Const")

加载一个变量也只需根据指针将其从内存中读出：

    case idExpr:
        emitComment("-> Id")
        // 找到 id 的内存偏移
        loc, _ := lookupSymtab(t.attr)
        // 将该地址对应的值存入 ACCUMULATOR1
        emitRM("LD", ACCUMULATOR1, loc, GLOBAL_POINTER)
        emitComment("load id value")
        emitComment("<- Id")

在计算一个带运算符（算术运算和比较）的表达式的值时，需要先求出左右子表达式的值。tmpOffset 的设置是为了让嵌套执行此处代码时，每一个 genExpr 的 tmpOffset 值都是不同的，从而在多层 opExpr 下能够将左子表达式的临时值存放在不同的位置；否则每次执行都会向同一个位置（即MP）读写内容，从而覆盖外层求出的结果。

    case opExpr:
        emitComment("-> Op")
        // 求左子表达式的值，存入 ACCUMULATOR1
        cGen(t.child[0])
        // 将 ACCUMULATOR1 的值存入内存偏移 tmpOffset
        emitRM("ST", ACCUMULATOR1, tmpOffset, MEMORY_POINTER)
        // 将 tmpOffset 加 1，即指向下一个内存偏移（当然后面存的不能重合了）
        tmpOffset--
        emitComment("op: push left")
        // 求右子表达式的值，存入 ACCUMULATOR1
        cGen(t.child[1])
        tmpOffset++
        // 将左子表达式的值存入 ACCUMULATOR2
        emitRM("LD", ACCUMULATOR2, tmpOffset, MEMORY_POINTER)
        emitComment("op: load left")

算术表达式的求解很简单，惟需注意上面执行完毕后左边对应AC2，右边对应AC1：

        switch t.op {
        case plusToken:
            // AC1 = AC2 + AC1
            emitRO("ADD", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op +")
        case minusToken:
            // AC1 = AC2 - AC1
            emitRO("SUB", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op -")
        case timesToken:
            // AC1 = AC2 * AC1
            emitRO("MUL", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op *")
        case overToken:
            // AC1 = AC2 / AC1
            emitRO("DIV", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op /")

小于运算符的情况，如果AC1<AC2，则AC1=0；否则AC1=1。

        case ltToken:
            // AC1 = AC2 - AC1
            emitRO("SUB", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op <")
            // 若 AC1<AC2（新 AC1<0），则往后跳两个指令
            emitRM("JLT", ACCUMULATOR1, 2, PROGRAM_COUNTER)
            emitComment("br if true")
            // 若 AC1>=AC2，则 AC1=0
            emitRM("LDC", ACCUMULATOR1, 0, ACCUMULATOR1)
            emitComment("false case")
            // 无条件跳一条指令
            emitRM("LDA", PROGRAM_COUNTER, 1, PROGRAM_COUNTER)
            emitComment("unconditional jmp")
            // 若 AC1<AC2，则 AC1=1
            emitRM("LDC", ACCUMULATOR1, 1, ACCUMULATOR1)
            emitComment("true case")

等于的情况类似，仅当AC1=AC2时AC1=0：

        case eqToken:
            emitRO("SUB", ACCUMULATOR1, ACCUMULATOR2, ACCUMULATOR1)
            emitComment("op ==")
            emitRM("JEQ", ACCUMULATOR1, 2, PROGRAM_COUNTER)
            emitComment("br if true")
            emitRM("LDC", ACCUMULATOR1, 0, ACCUMULATOR1)
            emitComment("false case")
            emitRM("LDA", PROGRAM_COUNTER, 1, PROGRAM_COUNTER)
            emitComment("unconditional jmp")
            emitRM("LDC", ACCUMULATOR1, 1, ACCUMULATOR1)
            emitComment("true case")

HNU 软件编译原理实验 3（Go 实现）

Tue, 25 Apr 2023 00:00:00 +0000

虽然课程从头到尾没提到过TINY语言，但实验三全都围绕着TINY构造。

代码已上传至GitHub，为防止篇幅过长，没有内置所有代码，仅对个人认为值得讲述的地方进行说明，可以对比阅读。

cyp0633/compiler-lab

TINY语言

TINY语言是《编译原理及实践》（Compiler Construction: Principles and Practice，之后简称CCPP）中用于演示的语言，杨某人课程中心实验包中也有其中译本PDF文档（虽然翻得不咋样）。

在该书的1.7.1节中，提到了TINY语言的特性：

没有过程，没有函数声明
所有变量都是整型，通过一个赋值定义
只有 if 语句和 repeat 控制语句
if 语句可选 else 分支，必须用 end 表示结束
有输入输出语句
表达式只有算术（加、减、乘、整除）和布尔表达式（仅有 < 和 =）
注释由花括号包裹

示例程序：

pascal

{ Sample program
  in TINY language -
  computes factorial
} 
read x; {input an integer} 
if 0 <x then { don't compute if x <= 0} 
  fact := 1; 
  repeat 
    fact := fact * x; 
    x := x - 1 
  until x = 0; 
  write fact {output factorial of x} 
end

该书同时提供了TINY语言编译器的源代码，见此网站。

词法分析器

TINY语言的词法，书中已有明确的DFA描述。

TINY词法分析器包含于 scan.c 和 scan.h 中，可以直接参考实现。这个词法分析器由语法分析器调用，并不会一次把源文件扫完，而是调用一次获取一个token。这和下图中的配合方式有点像。

词法分析器中有三个函数：

getNextChar：读取下一个字符。它维护了一个 lineBuf，即当前正在读取的代码行，在当前行读完的时候，会自动读下一行。
ungetNextChar：撤销上个 “读取下一个字符” 操作。注意到上图的DFA中有几条 [other] 边，这类似于状态转换图中的星号，代表这条边只会 “peek” 而不会真正读进来。
GetToken：读取下一个token，然后返回类型。

在原来的代码中有一个线性查找保留词表的函数，但似乎可以直接用map替代掉。话说C++ STL不是有map吗？

var reservedWords = map[string]tokenType{
    "if":     ifToken,
    "then":   thenToken,
    "else":   elseToken,
    "end":    endToken,
    "repeat": repeatToken,
    "until":  untilToken,
    "read":   readToken,
    "write":  writeToken,
}

对于源文件的读入方式，我选择了使用 bufio.Scanner。这玩意可比 io.Reader 好用多了。

`getNextChar`

// getNextChar 从 lineBuf 中读取一个字符，
// 如果 lineBuf 为空则从输入流中读取一行
func getNextChar() (byte, error) {
    // 本行已经读取完毕
    if linePos >= len(lineBuf) {
        lineNo++
        ok := sourceScanner.Scan()
        if !ok { // 文件末尾
            err := sourceScanner.Err()
            if err == nil {
                // EOF 的话不会返回 err
                eof = true
                return 0, io.EOF
            } else {
                // 真的出现错误了
                lineBuf = ""
                linePos = 0
                return 0, err
            }
        }
        lineBuf = sourceScanner.Text()
        linePos = 1
        return lineBuf[0], nil
    } else {
        linePos++
        return lineBuf[linePos-1], nil
    }
}

这个Scanner的默认分隔符就是换行，如果读取到末尾，会返回一个false，然后没有err（想不通为什么不是 io.EOF）。

eof 的作用后面说。

`ungetNextToken`

// ungetNextChar 将 lineBuf 中的一个字符退回
func ungetNextChar() {
    if !eof {
        linePos--
    }
}

不加eof判断的话 GetToken 会一直读最后一个字母，停不下来。

`GetToken`

这个函数是一个完整的状态机实现，包含的状态如上面DFA所示，每次走到DONE就代表识别完成了一个token。代码太长了就不放在文章里了。

值得注意的是状态里面没有保留字，因为这个词法分析器会先将非数字开头的字符串作为变量名，然后检查是否匹配保留字，并据此返回词类型。

有一个 tokenString 变量，顾名思义。只有变量名和数字等才需要记录，而对于注释之类的对语义完全没有作用的东西可以直接忽略掉。

This content is licensed under a Creative Commons Attribution-ShareAlike 4.0 International license.

HNU 软件编译原理实验 2（Go 实现）

Wed, 12 Apr 2023 00:00:00 +0000

做这次实验有点难受，我不知道该怪罪Go的类型系统还是杨某人的面向对象结构。

代码已上传至GitHub，为防止篇幅过长，没有内置所有代码，仅对个人认为值得讲述的地方进行说明，可以对比阅读。

cyp0633/compiler-lab

数据结构

产生式

Production 结构体与其说是产生式，不如说是产生式的右部，而直到LR(0) 项目中才记录了左部信息。

有两个特殊的文法符，$\epsilon$ 和 $#$，为了让它们在每一处都有相同的地址以方便比较，直接将定义写死在了代码里。

// epsilon 不属于非终结符，也不属于终结符！！！
// 看起来要用好多次，就先定义好了
var epsilonSymbol = GrammarSymbol{
    Name: "epsilon",
    Type: Null,
}

var endSymbol = TerminalSymbol{
    GrammarSymbol: GrammarSymbol{
        Name: "#",
        Type: Terminal,
    },
}

由于Go没有继承没有多态，只有嵌入以让一个结构体拥有另一个结构体的完整成员，那也无法使用一个 GrammarSymbol 指针指向终结符或非终结符。因此，在希望存储更多类型时，只能用一个 interface{} 解决。果然是著名的万物皆是interface。比如：

type NonTerminalSymbol struct {
    GrammarSymbol
    ProductionTable      []*Production               // 非终结符的产生式表
    NumOfProduction      int                         // 产生式数量
    FirstSet             map[interface{}]bool        // 该非终结符的 First 函数值
    FollowSet            map[interface{}]bool        // 该非终结符的 Follow 函数值
    DependentSetInFollow map[*NonTerminalSymbol]bool // 该非终结符的 Follow 函数中依赖的非终结符
}

而这里就带来了一个问题：interface{} 完全没有类型检查，可以放指针，也可以放结构体本身。这就要求类型检查覆盖到不正常的情况，算了，大道至简嘛——

go的教徒还住着毛坯房，毕竟大道至简

V2EX 网友

不过可以规定，此处的 interface{} 里存的全都是指针，并且代码实现保证同一个语法符仅存一份（即不会存在对象相同但指针不同）。

follow 依赖的非终结符完全没用过，倒不是说没用，而是觉得没必要。后面直接算的是所有非终结符的 follow。

LL(1)

LL(1) 分析表并没有使用预定义的cell，毕竟通过遍历一个slice查表的操作未免太不优雅了。

var LL1AnalysisTable = map[struct {
    *NonTerminalSymbol
    string
}]*Production{}

这里嵌入了一个匿名结构体，key的两个scope分别为非终结符和向前看的下一个语法符，value为对应的产生式。

LR(0)

和上面同理，既然项目集的本质是一个集合，就没必要使用数组这么傻的东西。

type ItemSet struct {
    // 状态序号
    ID int
    // LR(0) 项目表（其实是个集合）
    ItemTable map[LR0Item]struct{}
}

同时也直接砍掉了那几个cell，对LR(0) 分析表可以直接使用map映射。如下是 $\text{ACTION}$ 表的定义，用了两个匿名结构体。$\text{GOTO}$ 表定义同理。

// LR Action 表
// 由状态 ID 和终结符名称，到动作类型和编号的映射
var ActionTable map[struct {
    // 当前栈顶状态序号
    StateID int
    // 待读入的终结符名称
    TerminalSymbolName string
}]struct {
    // 动作类型
    Type ActionCategory
    // 动作编号，如归约的产生式编号和移进的下个状态
    ActionID int
}

同样能使用map优化的还有自动机的边表。一般的查询都是根据起始状态和驱动符查找到达状态的，使用map会快很多。

// LR(0) 自动机
var DFA struct {
    // 开始项集
    StartItemSet *ItemSet
    // map 优化的变迁边表
    // 通常查询更快，极端情况下也不会更慢
    EdgeSet map[TransitionKey]*ItemSet
}

方法

产生式

定义了终结符、非终结符和产生式的 First 函数。对于终结符，可以直接返回包含自己的集合。而对于非终结符，

不要忘了如果 First 已经计算完成，就不要再算一次了，毕竟值都存储到了对应的数据结构中。

而在 Follow 函数中，关于是否有新的加入，个人使用的是比较插入前后map长度变化，不过先检查key是否存在似乎更快点。

在这里引入了一个库：github.com/google/go-cmp/cmp，它能够提供比 reflect.DeepEqual 更好的比较。如果是两个指针，前者会比较指向的内容，而后者只比较地址。如计算产生式的 First 函数时：

    // 只有 epsilon，就直接返回
    if p.BodySize == 1 && cmp.Equal(p.BodySymbol[0], &epsilonSymbol) {
        return map[interface{}]bool{&epsilonSymbol: true}
    }

由于每次添加 $\epsilon$ 时都是引用了同一个实例，所以这么比较没什么问题。只是听说Go的反射挺慢的，这个怕不是会更慢……

说到反射那当然还是要用的，因为又回到了没有多态的问题。不像其他语言，基类指针可以访问基类的内容，Go仅凭一个 interface{} 根本无法获取它的真正类型。于是，如 Follow 初始化时添加非终结符的操作：

    // 初始化 FOLLOW 集合
    for _, A := range GrammarSymbolTable {
        // 如果不是非终结符，跳过
        if reflect.TypeOf(A) != reflect.TypeOf(RootSymbol) {
            continue
        }
        A.(*NonTerminalSymbol).FollowSet = make(map[interface{}]bool)
    }

使用反射就可以轻松判断真实类型了，当然也可以像是在非终结符 First 函数中，寻找 $\epsilon$ 产生式的代码这样：

    // 寻找 epsilon 的产生式（仅含 epsilon）
    for _, p := range nt.ProductionTable {
        if p.BodySize == 1 {
            symbol, ok := p.BodySymbol[0].(*GrammarSymbol)
            if ok && symbol.Type == Null { // 为什么不能放到一个 if 里啊！！！
                // 如果存在将 epsilon 加入该非终结符的 First 函数值
                nt.FirstSet[&epsilonSymbol] = true
            }
        }
    }

（现在我们知道，当然是可以放在一个if里的，用反射就优雅多了）

在求产生式的非终结符时，需要求某产生式右部某一部分的 First 函数。此处选择构造一个产生式求 First，然后一切交给GC，应该不会存在重复计算过多的问题。

                    // 先看成 A \Rightarrow \alpha B \beta，求 FIRST(\beta)
                    // 将 \beta 部分组合成一个产生式
                    tempProduction := Production{
                        BodySymbol: production.BodySymbol[index+1:],
                        BodySize:   len(production.BodySymbol[index+1:]),
                    }
                    betaFirst := tempProduction.First()

LL(1)

检测左递归使用的是DFS方法，每一层对某个特定非终结符的所有产生式进行搜索，在搜索路径上维护一个map，记录非终结符的出现与否（毕竟只有非终结符才有左递归这回事），思想比较像递归子程序法。如果当前非终结符已经处于那个map中，就代表有左递归。这样能同时检测直接和间接的左递归。

// 对所有非终结符检测左递归
func CheckLeftRecursion() (ret bool) {
    return checkLeftRecursion(make(map[string]bool), RootSymbol)
}

// 使用 DFS 检测左递归，rec 用于记录已经检测过的非终结符
func checkLeftRecursion(rec map[string]bool, curr *NonTerminalSymbol) bool {
    // 如果已经检测过，返回
    if rec[curr.Name] {
        return true
    }
    // 否则加入 map
    rec[curr.Name] = true

    for _, production := range curr.ProductionTable {
        // 长度为 0，返回
        if len(production.BodySymbol) == 0 {
            continue
        }
        // 是非终结符
        if symbol, ok := production.BodySymbol[0].(*NonTerminalSymbol); ok {
            if checkLeftRecursion(rec, symbol) {
                return true
            }
        }
    }
    return false
}

消除左递归其实就是套课本上的算法了，没有什么好说的。

检测左因子就是对某个非终结符的所有产生式首语法符进行查重，重点在 “有没有”，而提取左因子面临着一个取舍，在同一次提取中，无法既对尽量多的产生式进行提取，又提取出尽量长的公因子。在这篇博客中介绍了一种通过树实现的算法，不需要考虑取舍也不需要进行多次提取。

多好的算法啊，可惜有点复杂，我还是老老实实多次提取吧（然而还是100多行）。基本思想：

循环提取，直到检测不到左因子
先检测开头的因子是否有重复，确定首公因子之后再尝试延长公因子。如对于1123、114和514，先确定提取开头的1，然后延长到11
倾向于提取更多产生式的左因子（而不是提取更长的左因子），包括每次选择包含产生式最多的公因子进行提取（如123、145、245、255、244中提取2，因为有2的多于有1的），以及延长时遇到无法延长的产生式时直接放弃（如1123、1134、11156、11145只会延长到11，而不会放弃前两个来提取111）

另外还要注意新产生式为空时epsilon的问题。新非终结符的产生式和被移除的产生式序号一一对应，也可以重复利用。实在看不懂就看代码吧……

LL(1) 分析表的构造也是课本上就有的算法了，实现起来难度也不高。

LR(0)

LR(0) 写起来真的让我血压高，穷举变迁时已经得到了从哪个状态来、借由某个驱动符、到哪个状态去的信息，但却要再写一个求解DFA，再求一次变迁…… 真的不优雅，想了好久如何把它变得快一点，然后失败了。

求解变迁时常用的是直接调Goto函数，而这里由于是对某个项目集所有的项目求对应的变迁，所以不需要两层循环，直接一层循环即可。这里提前新建一个map newItemSets，对每个驱动符映射到其GOTO状态对应的项目集，对每个非归约项目直接把点后移之后加入新项目集就行了，遍历完成后，核心项就都有了。

    // 遍历项目集中的每个项目
    // 此处并不需要驱动符一层项目再一层，省点时间
    for item := range itemSet.ItemTable {
        // 如果已经是归约 / 接受项目（A \to \cdot \alpha），则不需要变迁
        if item.DotPosition == len(item.Production.BodySymbol) {
            continue
        }
        // 取出该驱动符对应的项目集
        itemSet := newItemSets[item.Production.BodySymbol[item.DotPosition]].ItemTable
        // 将项目 item 的点后移一位
        // 新的项目！
        item1 := LR0Item{
            NonTerminalSymbol: item.NonTerminalSymbol,
            Production:        item.Production,
            DotPosition:       item.DotPosition + 1,
            Type:              CoreItem, // 一定是核心项啦
        }
        // 将新项目加入项目集
        itemSet[item1] = struct{}{}
    }

至于求解DFA嘛，其实也就大差不差了，我甚至复制了一大段代码。

在SLR(1) 的检查之中，可以使用一个map（set）存放归约项集的各个左部（即 $A \to \alpha \cdot$ 的 $A$），一个map存放移进项集对应的驱动终结符集（即 $A \to \alpha \cdot a \beta$ 的 $a$），更方便计算交集。

接下来是构造LR分析表，我也不知道杨某人这句话是什么意思，那就先填个LR(0) 吧。

四个if-else让人血压挺高的，你问我为什么不用switch？因为case里面不能声明局部变量，所以 case symbol, ok := item.Production.BodySymbol[item.DotPosition].(*TerminalSymbol); ok 这样的判断就写不出来，着实不太方便。

        for item := range itemSet.ItemTable {
            // 判断项目类型
            // 为什么不用一个 switch？因为特么的 go 不支持 switch 里做声明
            if item.NonTerminalSymbol == RootSymbol && item.DotPosition == len(item.Production.BodySymbol) {
                // 接受项目 S' \to S \cdot
                // ACTION[i,#] = accept
                // code...
            } else if item.DotPosition == len(item.Production.BodySymbol) {
                // 归约项目 A \to \alpha \cdot
                // 对所有非终结符 a 或 #，ACTION[i,a] = reduce j
                // code...
            } else if symbol, ok := item.Production.BodySymbol[item.DotPosition].(*TerminalSymbol); ok {
                // 移进项目 A \to \alpha \cdot a \beta
                // action[i,a] = shift j
                // code...
            } else if symbol, ok := item.Production.BodySymbol[item.DotPosition].(*NonTerminalSymbol); ok {
                // 待约项目 A \to \alpha \cdot B
                // goto[i,B] = j
                // code...
            }
        }

This content is licensed under a Creative Commons Attribution-ShareAlike 4.0 International license.

HNU 软件编译原理实验 1（Go 实现）

Sat, 25 Mar 2023 00:00:00 +0000

真不巧，这个学期看起来又是一套自编新实验。虽然下面这段话有待商榷，但为了分，总不能不做吧。

不自己经历一次TINY语言的编译器构造过程，就等于没学这门课。经历过了，而且走通了，你就从现在的1/100, 飞跃到了1/3000，甚至1/10000。毕业后，你就拿着这个名片去华为，去阿里，去腾讯，去百度找工作，或者去北大，清华，上海交大，北航这些学校读研，绝对没问题。这个名片要比现在所谓的竞赛获奖的含金量大得多，别人相信得多。为什么？因为招聘官或者老师都是过来人，都知道编译技术是最难学的知识，没几个人真正学懂。现在你真正学懂了，别人刮目相看。

杨某人《编译技术课程试验指导书（2022版）》

代码已上传至GitHub，为防止篇幅过长，没有内置所有代码，可以对比阅读。

文章并未完成，而且 ~~不知道什么时候会施工完成~~ 应该弃坑了，不过代码写完了。

cyp0633/compiler-lab

从 “最简DFA构造法” 说起

构造DFA的方法算是本实验的前置知识，而杨某人自创的 “最简DFA构造法“并不是龙书提到的Thompson构造法。而要理解最简构造法，需要先理解” 原生构造法“。

原生构造法的核心思想是将正则表达式拆成多个基本运算，再将这些基本运算逐步组合成NFA。

比如正则表达式 $r \to a^+b^+$，可以拆分为 $r_1 \to a$、$r_2 \to b$、$r_3 \to r_1^+$、$r_4 \to r_2^+$、$r_5 \to r_3r_4$ 这五个正则表达式。然后将其各自转化为NFA。

在绘制 $r_3$ 对应的NFA时，将 $r_1$ 代入，并将整个NFA看作是一个状态 / 一个转换，下同。最后组合到 $r_5$ 即可得到 $r$ 的NFA。

而杨某人认为，一些空转换的作用仅仅是防止过度的反向转换。根据不同的出入边状况，自然构造法中的空转换可以省掉，以在防止倒灌（指顺着回边返回太远）的同时得到更简单的NFA。

连接

当 $s$ 有出边，$t$ 有入边时，在 $s$ 结束状态和 $t$ 开始状态处加入一个空转换。

否则，与Thompson构造法一致，$N(s)$ 的结束状态和 $N(t)$ 的开始状态重合。

Kleene闭包

有入边，有出边：同Thompson构造法
有入边，无出边：可以省掉后面的空转换
无入边，有出边：可以省掉前面的空转换
无入边，无出边：不需要空转换

当 $s^*$ 的NFA只含一个开始、一个接受状态，且无出入边时，可以缩成一个状态。

0或1个 $s?$

就是把Kleene闭包的顶上那一个空转换去掉，阻止继续接受即可。

并 $s|t$

当 $s$ 和 $t$ 都没有入边和出边时，转换如图所示。

如果 $s$ 或 $t$ 中任何一个有出入边，则先对其进行改造：

有入边，无出边：在前面加空转换
无入边，有出边：在后面加空转换
有入边，有出边：在两边各加一个空转换

另外还有带category属性的接受状态，需要在后面加一个空状态作为新的接受状态，以防止合并时category属性丢失。

数据结构

杨某人定义的一堆对象，在Go里当然不能继续用了。还好实验一没有继承多态类型推断之类的（实验二就有了），不然工作量又要暴涨。

字符集

字符集和字符集表

一个” 字符集 “代表的其实是一个字符集段，对于同一个字符集，可能会在 CharsetTable 内有多个 Charset 项，通过 SegmentID 相区分。

本实验的代码中，会保证每个字符集中，段不重合且按字符序递增。

正则表达式

操作数类型

Go的枚举确实有点太弱了，没办法。定义一个新类型，不过这个也算不上限制，可以随便赋值。

词素类型

可以定义一个 String() 方法，以打印其名字。

图（NFA、DFA）

这个就没啥好说的了……

方法

字符集

生成一个字符集

输入两个字符，输出一个index ID。

字符与字符的并运算

分两种情况，相等（返回一段）或不相等（返回两段）。也可以合并。

字符与字符集的并运算

题意要求，返回的必须是新字符集，其实这也为我们降低了难度，毕竟不用考虑插入段的复杂性。那就可以先将旧的字符集拷贝一份。

第一轮遍历，寻找可以包含的原字符集段，如有，就不用再合了。

第二轮遍历，寻找挨着边界的原字符集段，也就是 fromChar-1 或者 toChar+1，直接边界 +-1即可，不需要新段。

之后第三轮遍历，找到合适的位置，插入新段，然后将后面段的 SegmentID+1。

单元测试

This content is licensed under a Creative Commons Attribution-ShareAlike 4.0 International license.

HNU 电子实训 BSP 模块应用训练笔记

Wed, 24 Aug 2022 00:00:00 +0000

题目与BSP版权属于学校，代码请见 https://git.cyp0633.com/cyp0633/eecs-bsp-test-code-2，遵循GPLv3协议。

1. 串口1收发

计算机上利用串口助手，设置串口参数：“2400，8，N，1”（即：波特率2400bps，8个数据位。无奇偶校验位，一个停止位），顺序发送10字节的HEX数据到STC-B板，STC-B板将接收到的10字节数据再以倒序方式经串口1发送回计算机。

引入串口1使用的头文件 uart1.h，初始化传递波特率2400作为参数。然后设定接收条件，接收缓冲区指向一个空的大小为10的字符数组，匹配字符串指向一个空指针，设置字符串长度为0，字符串长度为0。并设置回调函数，当读取到符合上述条件的串口1数据包时，调用 sendBack 函数。

void sendBack()
{
    char temp;
    int i;
    for(i=0;i<5;i++)
    {
        temp=buffer[i];
        buffer[i]=buffer[9-i];
        buffer[9-i]=temp;
    }
    Uart1Print(buffer,10);
}

大致就是将 buffer 中的字符串首尾调换，然后通过串口1重新发回。

2. 串口2通信

两块STC-B板1和2通过串口2连接（485接口上：A、B、GND，或EXT上：P1.0（RXD）、P1.1（TXD）、GND），设置串口2参数：“1200，8，N，1”。STC板1往STC板2发送5字节数据，STC板2接收数据，计算它们的累加和，并将累加和的低8位通过LED灯显示，验证结果是否正确？（STC-B板1需多换几组数据验证）。

发送端

使用 Uart2Init 函数初始化串口2，设定RS485，波特率1200，设置每1s调用回调函数 sendData。

在 sendData 中，通过一个countdown全局变量设定每10s发送一次buffer中的内容（1、3、5、7、9），并将里面的每个数递增1（溢出时设为0x1）。

接收端

初始化串口2，波特率1200，初始化屏幕，并设置串口2接收缓冲区和回调函数，类似于题1。

在回调函数中使用一个for循环计算累加和，并将其与0xff的计算结果传入 LedPrint 显示在LED上。

3. 红外无线通信

与第2题的操作一致，仅两块STC-B板通信方式选用IR红外无线连接（而不是串口2）。注意：同一房间内，同时开启红外通信可能会互相干扰。

发送端

头文件引入红外，使用 IrInit 初始化红外为NEC格式，每1s设置调用回调函数。

回调函数内容与题2发送端类似，但考虑到红外特性将发送延迟设置为3s。

接收端

使用 IrInit 初始化红外为NEC格式，使用 SetIrRxd 指定缓冲区，然后设置收到数据包的回调函数。

在回调函数中行为类似于题2的接收端。

4. 实时时钟

初始化DS1302实时时钟芯片，并将其 “时分秒” 信息以 “时时—分分—秒秒” 格式显示在数码管上。然后验证 “STC-B学习板” 上的实时时钟在断电后，其时钟靠板上的纽扣电池仍能正常走时。

struct_DS1302_RTC time, temp;
unsigned char display[8];

void changeClock()
{
    temp = RTC_Read();
    display[0] = temp.second & 0x0f;
    display[1] = (temp.second>> 4) & 0x0f;
    display[2] = temp.minute & 0x0f;
    display[3] = (temp.minute>> 4) & 0x0f;
    display[4] = temp.hour & 0x0f;
    display[5] = (temp.hour>> 4) & 0x0f;
    display[6] = temp.day & 0x0f;
    display[7] = (temp.day>> 4) & 0x0f;
    Seg7Print(display[7], display[6], display[5], display[4], display[3], display[2], display[1], display[0]);
}

void main()
{
    time.year = 0x22;
    time.day = 0x22;
    time.month = 0x8;
    time.hour = 0x15;
    time.minute = 0x33;
    time.second = 0x22;
    DS1302Init(time);
    DisplayerInit();
    SetDisplayerArea(0, 7);
    LedPrint(0);
    SetEventCallBack(enumEventSys10mS, changeClock);
    MySTC_Init();
    while (1)
    {
        MySTC_OS();
    }
}

5. 非易失存储

数据可以在掉电情况下保留在非易失存储器（M24C02或DS1302）中的某个单元上。设计一段小程序：上电后，读取出非易失存储内某个单元数据，并将其值显示在LED灯上，再将这个数据 + 1后写回这个单元。分析这样的程序，如果拔插 “STC—B学习板” 电源（或按板上 “RST” 复位按键），会出现什么现象？（说明：DS1302需要靠纽扣电池才能在掉电时保存数据）

初始化NVM后使用 NVM_Read 读取0x05处的值作为初始值，并显示在LED上。如果值为0xf，则重置为0，否则将值自增1后写回0x05。这样的步骤在每次重置后都会进行，就实现了自增的效果。

6. 收音机

初始化启用FM_radio模块。收音机参数设定为91.8MHz，音量6。PHONE接口上插上耳机验证是否正确收到电台？

初始化一个 struct_FMRadio 结构体，设置频率918，音量6，三个GP都为0，然后传递给 FMRadioInit 函数。

7. 音乐播放器

用Music模块提供的API实现播放一段音乐。

使用 SetMusic 指定节拍、音调、乐谱数据、乐谱大小（用 sizeof 得到）以及显示方式，然后使用 SetPlayerMode 开始播放。

代码存放于 https://git.cyp0633.com/cyp0633/eecs-bsp-test-code/src/branch/master/music2。

8. 温度值计算

10位精度采集热敏电阻ADC值，编写程序（查表、或线性插值方法等）换算出正确温度值，并在数码管显示出来。热敏电阻参数10K/3950，（具体见 “案例测试” 中提供的参考资料。可设有效换算温度范围 - 5°C～+85°C）。

从其他示例程序找到了一个8位采样值到温度的的换算表：

int code tempdata[] = {239, 197, 175, 160, 150, 142, 135, 129, 124, 120, 116, 113, 109, 107, 104, 101,
                       99, 97, 95, 93, 91, 90, 88, 86, 85, 84, 82, 81, 80, 78, 77, 76,
                       75, 74, 73, 72, 71, 70, 69, 68, 67, 67, 66, 65, 64, 63, 63, 62,
                       61, 61, 60, 59, 58, 58, 57, 57, 56, 55, 55, 54, 54, 53, 52, 52,
                       51, 51, 50, 50, 49, 49, 48, 48, 47, 47, 46, 46, 45, 45, 44, 44,
                       43, 43, 42, 42, 41, 41, 41, 40, 40, 39, 39, 38, 38, 38, 37, 37,
                       36, 36, 36, 35, 35, 34, 34, 34, 33, 33, 32, 32, 32, 31, 31, 31,
                       30, 30, 29, 29, 29, 28, 28, 28, 27, 27, 27, 26, 26, 26, 25, 25,
                       24, 24, 24, 23, 23, 23, 22, 22, 22, 21, 21, 21, 20, 20, 20, 19,
                       19, 19, 18, 18, 18, 17, 17, 16, 16, 16, 15, 15, 15, 14, 14, 14,
                       13, 13, 13, 12, 12, 12, 11, 11, 11, 10, 10, 9, 9, 9, 8, 8, 8, 7,
                       7, 7, 6, 6, 5, 5, 54, 4, 3, 3, 3, 2, 2, 1, 1, 1, 0, 0, -1, -1, -1,
                       -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, -8, -9, -9,
                       -10, -10, -11, -11, -12, -13, -13, -14, -14, -15, -16, -16, -17,
                       -18, -19, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
                       -30, -32, -33, -35, -36, -38, -40, -43, -46, -50, -55, -63, 361};

使用 ADCexpEXT 初始化ADC，并初始化屏幕。每10ms回调calcTemp函数。

在calcTemp中，将10位取样右移2位变为8位，计算100次取样的累加和，并取平均值。将换算表中平均采样值的对应值显示在数码管上。

9. 扩展模板

外设模块中超声波、编码器、电子尺… 选取一个，能在数码管上显示相应物理量数值。

引入扩展模块头文件，使用 EXTInit 初始化超声波模块，初始化屏幕，设置10ms回调 showDist 函数。

使用 GetUltraSonic 获得超声波传感器的读数，将每位分出来显示在数码管上。

10. 直流电机

设计简单程序段，用两组参数（“50% 速度、正转”，和 “30% 速度、反转”）分别设置直流电机，并接上直流电机观察不同参数时电机转动情况。

设一个状态变量，按Key 1后更改其值，并输出另一种PWM信号。正转50% 使用 SetPWM(0, 0, 50, 500);，反转30% 使用 SetPWM(50, 300, 0, 0);。

我的 STC 单片机开发工作流

Wed, 29 Jun 2022 00:00:00 +0000

本文主要用作记录开发过程中使用的不同工具。主要也是课程导向的，所以可能并不会使用实际上更好的方法。设备是STC15F2P60S2。

添加设备库

先安装 Arm Keil uVision 5。由于课程需要，使用Keil的开发工具链，主要是懒得去学SDCC的语法差异，也懒得移植学校给的BSP库。

使用十分复古的STC-ISP来添加设备库。直接点击 “添加型号和头文件……” 即可。

创建项目

需要首先新建项目目录、一个C文件（空不空都行），以及所需的头文件和库文件（.lib），文件都放在项目文件夹中。这里我将C文件和库文件放到 source/ 目录，将头文件放到 inc/ 目录。

在uVision主界面顶部点击Project - New uVision Project来创建一个项目文件。由于Keil松散的文件管理，这个文件并不必须与源代码同目录同名，但为了遵循其他IDE的惯例，最好还是保持相同。

选择设备时可以在下拉栏里找到STC MCU database，然后选择你的STC芯片。

之后询问的STARTUP.A51没必要复制进来。

然后找到左边项目浏览器中的Target，如果没有下属Group就先创建一个，有了之后直接双击它，打开添加文件界面。将你的库文件和C代码添加进来。如果在这里添加头文件，要指定好目录，但如果是某种库的话可以留到后面添加，所以这里只添加了两个文件。

正常情况下C文件包含的头文件是会自动显示在C源代码下属的，就像上图这样。但是刚添加进文件的时候是没有的。

之后找到顶部Project菜单，选择Options for Target xxx，点击C51，找到Include Paths，在这里添加额外的包含目录。我的库文件在项目文件夹 inc/ 目录，故添加完成如图。

编写与构建项目

Keil本身是一个完善的IDE，那么对于写代码，我们自然是…… 用VS Code！

只是为了自动识别Keil的项目，需要再装一个插件。该插件的信息如下。

text

名称: Keil AssistantID: cl.keil-assistant 说明: An assistant for Keil uVision 版本: 1.7.0 发布者: CLVS Marketplace 链接: https://marketplace.visualstudio.com/items?itemName=CL.keil-assistant

在插件设置中指定Keil工具链UV4.exe的路径，就可以用VS Code打开工作区的同时自动识别Keil项目了。

VS Code自带的C language server能够完美地契合我们的需求，体验比Keil高到不知哪里去了。将鼠标移至特定Target上，甚至可以直接构建项目。

如果没有hex文件输出，可以修改uvproj文件中的一行，在tag之间加一个1，如下。或者在前面Target Options页面里找到Output，选上Create HEX file。

xml

`1`	`<CreateHexFile>1</CreateHexFile>`

区分多种编译选项

有时由于方便调试的原因，我们需要添加调试输出，如RS485难以调试，则在开发时也输出到USB串口；同时我们也不希望最终使用时带有这种调试信息，那么在C语言中常用 #define 语句来区分：

    Uart2Print(buf2, 8);
#ifdef DEBUG
    Uart1Print(buf2, 8);
#endif

可以使用多build target的方式，对每个target设定不同的define选项。从刚刚找到的Options for Target右边，点击File Extensions, … 按钮，然后新建一个target，并选择其为当前target。然后打开之前P3提到过的C51选项，在define里设置想提前声明的内容即可。

刷写项目

这里仍然不使用STC-ISP，而使用开源的stcgal。

grigorig/stcgal

命令很简单，一般来说只需要一把梭：

bash

`1`	`stcgal some-program.hex -p COMx`

由于程序似乎是为Linux设计的，在Windows下必须指定COM号。一般这个号和特定USB接口有对应关系，用STC-ISP看一下就行了。

这样我们可以将工作流与vscode深度融合，直接在其终端中操作，编辑、构建、刷写一体化，此时基本不需要Keil。

参考文献

数电课程模型机设计：模型机整合

Mon, 27 Dec 2021 00:00:00 +0000

内容还未完成，等待更新，其中包含高度不稳定的内容，仅供参考。
文章更新较慢，可以先在GitHub浏览工程文件。

所有代码现已开放至GitHub：https://github.com/cyp0633/ModelComputer。建议在Releases代码里下载ZIP格式的源代码，更稳定。

同时提供一些资源文件，可以从https://drive.cyp0633.icu/s/eVc6获取，包含验证用的内存初始化MIF文件、实验报告和成品模型机图（PDF格式）。

本文大概遵循老师教学视频中使用的方法，即每次搭建几个元器件，并对其做验证。

关于之前部件的内容，请翻到本文底部，浏览“数电模型机”Tag下的其他文章。

模型机整体图如下图所示，后面的过程可能会用到控制信号和数据通路间的关系。

指令计数器、多路复用器、RAM、指令寄存器

指令计数器 PC，存储当前指令在RAM中存放的地址。
多路复用器 MUX，选择从PC、S和D的数据之一传入RAM。
随机存储器 RAM，存放待执行的命令。
指令寄存器 IR，用于暂存当前正在执行的指令。

这几部分较简单，建议跟随教学视频完成。

在调试RAM的过程中，如果遇到不能在LPM_FILE中输入"./xxx.mif"从而无法读取初始化内容的情况，可以用文本编辑器（VS Code等，实在没有的话记事本也行）打开项目BDF文件，查找定位现在LPM_FILE对应值的位置，将文件路径部分替换成下面这样：

verilog

  (parameter
    "LPM_FILE"
    "\"./example.mif\""
    "File containing initial contents of memory array"
    (type "PARAMETER_STRING"))

如果编辑mif时提示数字过大，那多半是默认十进制，要修改为二进制，可以用文本编辑器打开mif文件，将DATA_RADIX改成BIN。

如果在Quartus 9编译后的Timing Summary中出现"Slack: Not Operational"，则代表有锁存器，回去改模块的代码吧。我的代码中也有此提示，但这是故意而为之，是启停控制模块的必然结果，绕过后则不会有此提示。

通用寄存器组、ALU

通用寄存器组，下降沿响应，用来保存操作数和运算结果等信息。
算术逻辑单元ALU，组合部件，用于执行加、减、与、非运算，或提供数据的通路。

搭建电路的方法，视频里已给出，所以这里主要介绍验证的方法。

这里我们只需要仿真验证通用寄存器组和ALU两个模块，所以添加引脚的时候只需要添加这两个模块有关的引脚，即CLK、M、SEL、RA、RWBA、WE、C、DREG、SREG、Z。

DREG和SREG输出主要用于截取寄存器输出到ALU输入间传送的数据，方便debug。

此外，寄存器内的数值默认一开始都是0（Undefined），除了一点一点用ALU指令自加得到想要的数值之外，也可以在Verilog内直接给寄存器赋初值（默认为8’b0），如：

verilog

1
2
3

    reg [7:0] a=8'b00110110;
    reg [7:0] b=8'b10001011;
    reg [7:0] c=8'b11001110;

根据ALU引脚关系来确定输入的ｍ和sel值。以下的顺序并没有严格指定，但请使你的测试覆盖各种情况，以免组装完成后出现意想不到的错误，下同。

第一个上升沿，我们先执行加法。clk设为初始值1、5ns增1的波形，m=1允许运算，sel=1001代表ADD，ra和rwba输入加的寄存器地址，we=0允许数据输入。

这样，你就可以在c、z和上升沿后的dreg中看到运算结果。

然后第二个上升沿，我们执行减法。和前面差不多，只是sel=0110。减法时ALU运算的是t=b-a，对应的是dreg-sreg，也就是rwba指向的值减raa指向的值，对应关系下同。

按位与和取反也差不太多，这么搞就行了。

仿真波形如下图所示（不要在意最下面那三个REG，有点问题）。

波形看起来很奇怪？请不要忘了，ALU是组合部件，运算很快完成；寄存器是时序部件，更新需要等下降沿。

移位逻辑

移位逻辑，组合部件，用于将输入的数据循环向左向右移，将溢出的位另输出至Cf。

在上面的结构图中，移位逻辑是放在ALU后面的。当然首先要把移位逻辑模块放到图上了。

因为左移右移进行的时候，肯定是t=b的，ALU不需要输出Cf，所以我们可以直接用一个或门将两路数据连接起来。

也可以在t和a之间接一个输出，方便观察。

反正针脚又没怎么变，所以可以沿用寄存器和ALU的波形文件，只需加入fbus/flbus/frbus输入就行了。

在波形文件中，sel表示ALU执行计算的时候（1001/0110/1011/0101），fbus=1，flbus和frbus=0，代表移位逻辑作为数据通路，直接将输入的数据输出。

sel=1010时，代表RSR或RSL，ALU作为数据通路，让移位逻辑负责移动数据，得留两个下降沿的时间，一个给左移一个给右移。

仿真波形如下图。

40-60ns处，就是左移一下右移一下，恢复原来的样子。进位完全正常。

控制信号产生逻辑、SM、指令译码器、状态寄存器

控制信号产生逻辑，组合部件，接收指令译码器输出，产生每个模块所需要的控制信号。
SM，下降沿敏感，用于区别取指令周期和执行指令周期。
指令译码器，组合部件，将8位指令码映射为对应指令。
状态寄存器，下降沿敏感，存储cf和zf，并在使能为1的时候改变。

之前的RAM电路需要依靠三态门来隔离输入和输出，而现在我们直接将总线接到双向的dio口上，同时负责输入输出。所以总线上的数据要协调好。

然后就是把剩下的元件一次加进去，搭建的时候可以参考上面的模型机整体结构连接。只连上这几个元件而没有其他功能加入的电路没截图，但带有调试引脚的模型机的结构大概如下图。

记得将一些信号连接到output引脚，多留一些调试用的输出，这样便于查看各种控制信号的值和过程量，方便debug，比如控制信号、总线数据、通用寄存器输出、多路复用器输出、指令寄存器输出、指令计数器的输出。可以参考上图设置输出引脚。

整合与调试

MIF文件编写

当你认为上面的部件全都连接完成的时候，只需要时钟信号、输入和一个写得正确的MIF文件就可以让模型机跑起来了。这个MIF文件定义了RAM在开始运行时的内容，但仿真结束或FPGA板断电之后并不会被修改，因为RAM断电即丢数据的特性是by design的，真实的电脑也是这样。

随着时钟的flip-flop，指令计数器的值改变，它的一个一个值传入RAM的address端，dio端就读出了指令或是地址（JMP/JZ/JC指令）内容。如果是指令，就将其送入指令译码器，然后变成控制信号，进行下一步的操作。因为指令计数器的自增或是装载特性，模型机就可以自动寻找下一个指令执行，而指令需要在MIF文件中初始化。

一句话来概括，就是以前用控制信号或手动输入指令来控制，属于走一步教一步；现在用MIF文件让它自己读指令，相当于记住了下面的指令内容，给它一个信号它就能自己按路径跑。

MIF文件从0开始向下编写，除三种跳转指令占两位外，每个指令占一位地址。遇到跳转，则与if语句的逻辑相似。

输入与输出

正如实验四和上面我们提到的，三态门可以控制通断，从而控制输入输出。只要将输入总线和输出总线与模型机相连，然后分别用三态门（Quartus中搜索TRI）隔开，将输入输出使能控制信号作为条件，外部输入输出部分就完成了。下图中的inputdata另有输入引脚连接，图中未绘出。注意大于一位的都要用总线绘制。三态门的作用是在使能为1时原样通过数据，否则门后为高阻态。

停机（HALT）和NOP指令

HALT指令通过将SM_EN置0，从而停止取指实现。如果要恢复运行，只需要加一个输入，将SM_EN拉到1即可。所谓的”真正的停机“，可能指的是门控时钟？没有太大必要实现。

NOP指令需要让模型机保持现在的状态两个时钟周期，然后执行下一条指令。这个时候你什么都不需要做，只需要让WE=1，禁止总线向寄存器输入数据。

调试

还记得我们创建的一大堆调试引脚吗？它们的作用就是输出过程量，在执行出错的时候找到是哪里的信号出错了，从而针对性改正。有点像打断点添加中间变量检测，不是吗？因为指令常常牵一发而动全身，我们可以找到发现异常的地方，然后逐条往回推，直到找到真正执行错的地方。至于怎么调试，就很依赖对模型机结构的熟悉程度了。

不过这里有一种情况很难查出来。如果你发现总线上输入/输出的数据并不是你想要的数据，特别是凭空不知道从哪冒出来的数据，多半是总线上输出打架了：同时只有一个部件能够在模型机总线上写入数据，很可能是移位逻辑。

标准测试指令文档

标准测试指令由老师给出，包含了一些分支，能够检验大部分指令的执行情况，所以如果你能够实现所有指令，建议使用标准指令文档。

对于电脑仿真的文档，需要预先将修改寄存器代码，将C寄存器的值初始化为1000 0000。除此之外，还需要在第3-4个时钟周期输入1000 0011，才能按照预期的情况运行。

对于下板的测试文档，需要将输入长期设为1000 0011，毕竟执行很快（3MHz），你无法在输入的一瞬间将按钮拨上去，然后瞬间拨下来。

下板测试

分配引脚

Assignments - Pin

时钟使用6MHz的CLK1，将clk分配至Pin 17。

输入使用开关，比如从高位到低位71、70、69、67、65、64、63、60，代表左边8个开关，正好对应从高位到低位8位输入。

输出使用LED灯，比如118、115、114、113、112、104、103、101，代表左边8个LED灯。如果你想用数码管，大概思路是将8位输出转BCD码，然后使用一个译码器轮流输出（因为是共阴极数码管）。

下载

连接板子，打开Programmer，在Hardware Setup中选择设备，然后点击Start即可。如下图。

如果你做到现在，你就做出了一台足够优秀的模型机。我做出最终的成品图，可以下载开头链接中的文件来浏览。以下模块不会增加基本功能，也不会魔改出流水线四发射双ALU分支预测之类的骚操作，但（可能）可以增强使用体验。

附加模块设计

这部分建议参考我的设计报告和代码来研究，在文章顶部链接中。

启停控制

这是一个优先级非常高的启停控制，因为它控制着输入到模型机内的时钟。本是为按钮设计的，没写消抖，就放到开关上了。

将开始按钮作为输入，将暂停按钮作为重置。在INIT状态下，只要检测到开始按钮

**副作用：过不了Timing Requirements。**因为将时钟阻断会造成锁存，从而clock hold变为N/A。

状态显示

用于显示停机原因，HALT或是上个模块造成的Pause。

向凌老师致敬，没有她的帮助，我可能会晚很长时间才能做出像样的模型机。

数电课程模型机设计：SM & 指令寄存器 & 状态寄存器 & 指令计数器 & 通用寄存器组 & RAM（Verilog 实现）

Wed, 15 Dec 2021 00:00:00 +0000

以下代码虽经本人检查，但并未经过验收，仅供参考，保留随时更改甚至推倒重来的可能。

前几个部分使用Verilog实现，还是比较简单的。最重要的是posedge和negedge的使用。代码中部分由GitHub Copilot生成。

AM使用Block Diagram，借助Quartus自带Megafunction实现。

SM

看懂表格就能做，非常简单。

只在时钟下降沿作用，其他时候不作用，所以使用negedge clk来捕获时钟信号下降沿。

CLK	EN	功能
下降沿	1	SM<=SM取反
下降沿	0	SM不变

verilog

module SM(clk,EN,z);
    input clk,EN;
    output z;

    reg z;

    always @(negedge clk) begin
        if(EN) z <= ~z;
    end

endmodule //SM

IR / 指令寄存器

CLK	IR_LD	功能
下降沿	1	d写入ir

应该没什么好讲的吧。

verilog

module IR(clk,ir_ld,d,ir);
    input clk,ir_ld;
    input[7:0] d;
    output[7:0] ir;

    reg[7:0] ir;
    
    always @(negedge clk) begin
        if(ir_ld) begin
            ir <= d;
        end
    end
endmodule

PSW / 状态寄存器

此程序目前存在一个问题：第一个下降沿，若cf_en或zf_en为0，c或z会变成未知值。目前把它们都设置为1，为数据做一个初始化，来规避这个问题。

CLK	控制信号	功能
下降沿	$cf_en=1$	cf写入c
下降沿	$zf_en=1$	zf写入z

这里讲一个之前一直没注意的事情。本程序可以使用两个always块。组合逻辑模块，处理cf和zf的使能；时序逻辑模块，处理下降沿更新。组合逻辑的结果由寄存器负责暂存。当然，也可以使用三个，一个处理cf，一个处理zf，一个侦测时钟信号，但生成的RTL视图实际上是一样的。

如果将cf_en,zf_en等不带沿的条件和negedge clk写到一个always条件内，Quartus会提示 10122 错误：在一个always块中，双沿的检测（就是普通的always @(n)）和单上升 / 下降沿是不能共存的。可以参考 logic - Single and double-edge expressions (Verilog) - Stack Overflow。

需要注意，之前所讲的 “输入必须都放在always条件里”，只适用于“在这些输入值改变的时候输出值需要立刻改变” 的时候，即同时侦测信号的上升沿和下降沿，这样输入值一旦改变，就可以及时的改变输出值。但时序电路不需要，如PSW只需要在时钟下降沿的时候根据两个使能信号的值更新输出就行了。所以输入和使能都没有必要放到always里，只需要在if侦测就行了。

下面是仅使用单cf_en的结果。

verilog

module PSW(clk,cf_en,zf_en,cf,zf,c,z);
    input clk,cf_en,zf_en,cf,zf;
    output c,z;
    reg c,z;
    reg cTemp,zTemp;

    always @(negedge clk) begin
        if(cf_en) begin
            c<=cf;
        end
        if(zf_en) begin
            z<=zf;
        end
    end
endmodule //PSW

PC / 指令计数器

仍然是看表格就能做。

这个 “a向入c” 的意思是将a的数据导入c。

CLK	IN PC	LD PC	功能
下降沿	1	0	$c[7..0]$ 中数据自加1
下降沿	0	1	$a[7..0]$ 向入 $c[7..0]$

verilog

module PC(ld,inc,clk,a,c);
    input ld,inc,clk;
    input[7:0] a;
    output[7:0] c;

    reg[7:0] c;

    always @(negedge clk) begin
        if (ld) begin
            c <= a;
        end else begin
            if (inc) begin
                c <= c + 1;
            end
        end
    end
endmodule //PC

REG / 通用寄存器组

不只有表里看起来这么简单。

任何时候都是能够读取的，只有写受下降沿限制。因为写的时候只由RWBA指定寄存器地址，所以RAA并没有什么关系。

读取只是把当前的值忠实读出来而已，如果有写入那就读出来新的值。

明明是寄存器，但表中甚至没有描述寄存器部分…… 也不难，定义三个八位的reg变量，就是寄存器的核心部分了，也就是读写的对象。

操作	CLK	WE	$RAA[1..0]$	$RWBA[1..0]$	功能
读			00或01或10	00或01或10	根据 $RAA[1..0]$ 的值从A,B,C中选择一个寄存器的值由S口输出根据 $RWBA[1..0]$ 的值从A,B,C中选择一个寄存器的值由D口输出
写	下降沿	0	XX	00或01或10	控制信号WE为0，根据 $RWBA[1..0]$ 的值, 在时钟下降沿将外部输入写入A,B,C三个寄存器中的某个寄存器。

寄存器是由负责读取的组合逻辑电路和负责写入的时序逻辑电路合并而成的。其读的状态不受写的状态影响，使用阻塞赋值；写则使用非阻塞赋值。

对于RAA和RWBA的输入，00代表A，01代表B，10代表C，都好理解，但如果输入11，仍然要输出C，而不是输出0或者高阻态之类的。可以直接写A、B、default。

verilog

module Register(WE,clk,RA,WA,i,S,D);
    input WE,clk;
    input [1:0] RA,WA;
    input [7:0] i;

    output[7:0] S,D;

    reg [7:0] S,D;
    reg [7:0] a,b,c;

    always @(RA) begin
        case(RA)
            2'b00: S=a;
            2'b01: S=b;
            2'b10: S=c;
            dmodule Register(WE,clk,RA,WA,i,S,D);
    input WE,clk;
    input [1:0] RA,WA;
    input [7:0] i;

    output[7:0] S,D;

    reg [7:0] S,D;
    reg [7:0] a=8'b00110110;
    reg [7:0] b=8'b10001011;
    reg [7:0] c=8'b11001110;

    always @(RA) begin
        case(RA)
            2'b00: S=a;
            2'b01: S=b;
            default: S=c;
        endcase
    end

    always @(WA) begin
        case(WA)
            2'b00: D=a;
            2'b01: D=b;
            default: D=c;
        endcase
    end

    always @(negedge clk) begin
        if(WE==0) begin
            case(WA)
                2'b00: a<=i;
                2'b01: b<=i;
                2'b10: c<=i;
            endcase
        end
    end

endmodule //Register

RAM

RAM包含一个QPF文件和一个MIF文件。QPF文件用于描述电路，而MIF文件用于定义RAM初始的内容。所谓初始值，就是在你没有向某个地址的内存块输入值的情况下，它默认输出的值。

新建一个Memory Initialization File，使用默认的256*8即可。里面随便填点东西，可以右键选择Custom Fill Cells搞点花样，比如使用梯度为1的Increment，可以将每个单元格赋给与它地址相等的值。

再新建一个Block Diagram File，这么画。注意三态门出来的线必须是总线（粗细可辨）。

实际上它是和指导书上有一定区别的。如果有多余的引脚，无需搭理。

双击表格可以修改参数，改成一样的就行。LPM_FILE填入刚刚MIF的相对路径，也就是说如果目录相同可以使用 “./xxx.mif” 表示，一定要带双引号。绝对路径（如D:/test/test.mif或 / root/test/test.mif）也可以。

本文代码所用波形文件在这里可以下载，建议仅用于参考波形。

数电课程模型机设计：多路开关、移位逻辑和控制信号产生逻辑（Verilog 实现）

Mon, 06 Dec 2021 00:00:00 +0000

以下代码虽经本人检查，但仅移位逻辑经过仔细验收，仅供参考。

多路开关

多路开关做起来还是很简单的，一个case语句就能搞定。记得加default，防止生成锁存器。

verilog

module mux (MADD,A,B,C,OUT);
    input[1:0] MADD;
    input[7:0] A,B,C;
    output[7:0] OUT;

    reg[7:0] OUT;

    always @(MADD,A,B,C) begin
        case (MADD) 
            2'b00: OUT=A;
            2'b01: OUT=B;
            2'b10: OUT=C;
            default: OUT=8'b0;
        endcase
    end
endmodule //mux

移位逻辑

这个应该也不算很难。我将输入的三个FBUS、FLBUS和FRBUS合成一个BUS，这样用case语句一起处理或许优雅一些（？）

可以参考下面这张图进行设计。其他情况直接全输出高阻，不用管别的，以防多路输出冲突。

verilog

module Shift_Register (F_BUS,FL_BUS,FR_BUS,a,W,Cf);
    input F_BUS,FL_BUS,FR_BUS;
    input[7:0] a;
    output[7:0] W;
    output Cf;
    
    reg[7:0] W;
    reg Cf;

    wire[2:0] BUS;
    
    assign BUS = {F_BUS,FL_BUS,FR_BUS};
    
    always @(BUS) begin
        case (BUS)
            3'b100: begin
                W = a;
                Cf = 0;
            end
            3'b010: begin
                W  = {a[6:0],a[7]};
                Cf = a[7];
            end
            3'b001: begin
                W  = {a[0],a[7:1]};
                Cf = a[0];
            end
            default: begin
                W = 8'bZZZZZZZZ;
                Cf = 0;
            end
        endcase
    end
endmodule //Shift_Register

控制信号产生逻辑

正常来说，如果希望用直接assign这种比较优雅的写法，你需要逐个摸清控制命令的运行模式，即每种IR对应的各个控制信号的值，列个表，然后找每个控制信号在什么命令输入的时候值为1。

要不然，就用一堆条件语句，只是省掉了反查的过程，还是得分析，也不优雅。

但是，老师把这个表已经列出来了，省下了大把的时间：

我们只需查找每一列输出信号对应的输入信号就行了。规定的信号针脚和表中的控制信号可能有所不同，可以参阅下面的源代码，我在注释中写了一些对应关系。

但是请注意，这里并没有包含所有的指令，比如INPUT。

空白的区域不清楚怎么搞，但我是在这部分输出了0。JZ/JC(T) 指的是JZ&&Z或JC&&C，这两种输出是等效的，虽然判断条件看起来不同；相对的，JZ/JC(F) 就是JZ&&(~Z) 或JC&&(~C)。

源代码如下，部分难以使用几个输入或表示的，我才会使用always语句。

后面整合的时候会知道，MOVB和MOVC的时候，要指定内存地址，需要将C寄存器中的数值输出，所以REG_RA（RAA）的always块中，不能因为MOVB中有一个固定的11就不作为条件；相反，为了将C忠实地输出，需要将三个MOV全都加进去；REG_WA（RWBA）也一样。

此外，上表没有包含NOP的指令输出，经测试只需要REG_WE=1即禁止读写即可，防止总线上数据污染寄存器。

verilog

module control_signal (MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,IR,SM,REG_RA,REG_WA,MADD,ALU_S,PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN);
    input MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,SM;
    //    MOVA,MOVB,MOVC,ADD,SUB,AND, NOT, RSR,RSL,JMP,JZ-T,JC-T,IN, OUT, NOP,HALT,SM
    input[7:0] IR;
    output[1:0] REG_RA,REG_WA,MADD;
    //          RAA,   RWBA,  MADD
    output[3:0] ALU_S;
    //          S
    output PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN;
    //     LD PC,IN PC, /WE,   XL,    DL,    M,    F-BUS,   FL-BUS,   FR-BUS,   LD IR,            SM,

    reg[1:0] MADD,REG_RA,REG_WA;
    reg[3:0] ALU_S;
    
    assign RAM_DL = (~SM)||MOVC||JMP||(JZ&&Z)||(JC&&C); // 取指, MOVC,JMP,JZT,JCT
    assign RAM_XL = MOVB&&(~SM); //MOVB
    assign PC_LD = JMP||(JZ&&Z)||(JC&&C); //JMP,JZT,JCT
    assign PC_INC = (~SM)||(JZ&&~Z)||(JC&&~C); // 取指, JZF,JCF
    assign IR_LD = (~SM); // 取指
    assign SHI_FBUS = ADD||SUB||AND1||NOT1||OUT1||MOVA||MOVB; //ADD,SUB,AND,NOT,OUT,MOVA,MOVB
    assign SHI_FLBUS = RSL; //RSL
    assign SHI_FRBUS = RSR; //RSR
    assign ALU_M = ADD||SUB||AND1||NOT1||RSR||RSL||OUT1;
    assign REG_WE = (~SM)||OUT1||MOVB||JMP||JZ||JC||HALT||NOP;
    assign CF_EN = ADD||SUB||RSR||RSL;
    assign ZF_EN = ADD||SUB;
    assign SM_EN = ~HALT;
    assign IN_EN = IN1;
    assign OUT_EN = OUT1;
    
    always @(SM,MOVB,MOVC) begin //MADD
        if(~SM) MADD=2'b0;
        else if(MOVB) MADD=2'b10;
        else if(MOVC) MADD=2'b01;
        else MADD=2'b0; // 不锁存只能这样了吧？
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,OUT1,MOVA,MOVB) begin //ALU_S
        if(ADD||SUB||AND1||NOT1||RSR||RSL||OUT1||MOVA||MOVB) ALU_S[3:0]=IR[7-:4];
        else ALU_S=4'b0;
    end

    always @(ADD,SUB,AND1,MOVA,MOVB,MOVC) begin //RAA
        if(ADD||SUB||AND1||MOVA||MOVB||MOVC) REG_RA=IR[1-:2];
        else REG_RA=2'b0;
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,IN1,OUT1,MOVA,MOVB,MOVC) begin//RWBA
        if(ADD||SUB||AND1||NOT1||RSR||RSL||IN1||OUT1||MOVA||MOVB||MOVC) REG_WA=IR[3-:2];
        else REG_WA=2'b0;
    end
    
endmodule

module control_signal (MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,IR,SM,REG_RA,REG_WA,MADD,ALU_S,PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN);
    input MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,SM;
    //    MOVA,MOVB,MOVC,ADD,SUB,AND, NOT, RSR,RSL,JMP,JZ-T,JC-T,IN, OUT, NOP,HALT,SM
    input[7:0] IR;
    output[1:0] REG_RA,REG_WA,MADD;
    //          RAA,   RWBA,  MADD
    output[3:0] ALU_S;
    //          S
    output PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN;
    //     LD PC,IN PC, /WE,   XL,    DL,    M,    F-BUS,   FL-BUS,   FR-BUS,   LD IR,            SM,

    reg[1:0] MADD,REG_RA,REG_WA;
    reg[3:0] ALU_S;
    
    assign RAM_DL = (~SM)||MOVC||JMP||(JZ&&Z)||(JC&&C); // 取指, MOVC,JMP,JZT,JCT
    assign RAM_XL = MOVB&&(~SM); //MOVB
    assign PC_LD = JMP||(JZ&&Z)||(JC&&C); //JMP,JZT,JCT
    assign PC_INC = (~SM)||(JZ&&~Z)||(JC&&~C); // 取指, JZF,JCF
    assign IR_LD = (~SM); // 取指
    assign SHI_FBUS = ADD||SUB||AND1||NOT1||OUT1||MOVA||MOVB; //ADD,SUB,AND,NOT,OUT,MOVA,MOVB
    assign SHI_FLBUS = RSL; //RSL
    assign SHI_FRBUS = RSR; //RSR
    assign ALU_M = ADD||SUB||AND1||NOT1||RSR||RSL||OUT1;
    assign REG_WE = (~SM)||OUT1||MOVB||JMP||JZ||JC||HALT||NOP;
    assign CF_EN = ADD||SUB||RSR||RSL;
    assign ZF_EN = ADD||SUB;
    assign SM_EN = ~HALT;
    assign IN_EN = IN1;
    assign OUT_EN = OUT1;
    
    always @(SM,MOVB,MOVC) begin //MADD
        if(~SM) MADD=2'b0;
        else if(MOVB) MADD=2'b10;
        else if(MOVC) MADD=2'b01;
        else MADD=2'b0; // 不锁存只能这样了吧？
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,OUT1,MOVA,MOVB) begin //ALU_S
        if(ADD||SUB||AND1||NOT1||RSR||RSL||OUT1||MOVA||MOVB) ALU_S[3:0]=IR[7-:4];
        else ALU_S=4'b0;
    end

    always @(ADD,SUB,AND1,MOVA,MOVB,MOVC) begin //RAA
        if(ADD||SUB||AND1||MOVA||MOVB||MOVC) REG_RA=IR[1-:2];
        else REG_RA=2'b0;
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,IN1,OUT1,MOVA,MOVB,MOVC) begin//RWBA
        if(ADD||SUB||AND1||NOT1||RSR||RSL||IN1||OUT1||MOVA||MOVB||MOVC) REG_WA=IR[3-:2];
        else REG_WA=2'b0;
    end
    
endmodule

照例，下面提供三个部件仿真时使用的波形文件，使用Quartus Prime 21.1生成：下载链接。

数电课程模型机 CPU 设计：译码器和 ALU（Verilog 实现）

Tue, 30 Nov 2021 00:00:00 +0000

译码器

译码器的指令系统表如下图所示。

译码器做起来其实不难，当编码符合要求的时候，把相应的汇编符号输出设为1就行了。

R1、R2代表操作寄存器的地址，可以为A、B或C寄存器中的任何一个，地址分别为00、01和10。

所谓” 符合要求 “，可以举个例子。比如NOT的编码是 0101 R1XX，R1代表寄存器1的地址，XX是通配符，所以可以做匹配 IR[7-:4]==4'b0101，而且应为寄存器地址的地方不能是11。（话说也没多少人会在这个位置传进11吧…… 除了喜欢点一杯炒饭的测试工程师）

特别注意的是，有三种MOV指令。这里定义第一种MOV指令为MOVA，第二种为MOVB，第三种为MOVC。我先使用1100匹配进MOV，然后再区分MOVA、MOVB和MOVC。

verilog

module decoder (EN,IR,MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT);
    input EN;
    input[7:0] IR;
    output MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
    reg MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
always @(IR,EN) begin
    if(EN==1'b1) begin
        if (IR[7-:4]==4'b1100) begin //MOV
            if(IR[3-:2]==2'b11) begin //MOVB 11R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
            else if (IR[1-:2]==2'b11) begin //MOVC R1111
                MOVA=1'b0;
                MOVB=1'b0;
                MOVC=1'b1;
            end
            else begin //MOVA R1R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
        end
        else begin
            MOVA=1'b0;
            MOVB=1'b0;
            MOVC=1'b0;
        end
        if (IR[7-:4]==4'b1001 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //ADD
            ADD=1'b1;
        end
        else ADD=1'b0;
        if (IR[7-:4]==4'b0110 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //SUB
            SUB=1'b1;
        end
        else SUB=1'b0;
        if (IR[7-:4]==4'b1011 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //AND
            AND=1'b1;
        end
        else AND=1'b0;
        if (IR[7-:4]==4'b0101 && IR[3-:2]!=2'b11) begin //NOT
            NOT=1'b1;
        end
        else NOT=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b00 && IR[3-:2]!=2'b11) begin //RSR
            RSR=1'b1;
        end
        else RSR=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b11 && IR[3-:2]!=2'b11) begin //RSL
            RSL=1'b1;
        end
        else RSL=1'b0;
        if (IR[7:0]==8'b0011_0000) begin //JMP
            JMP=1'b1;
        end
        else JMP=1'b0;
        if (IR[7:0]==8'b0011_0001) begin //JZ
            JZ=1'b1;
        end
        else JZ=1'b0;
        if (IR[7:0]==8'b0011_0010) begin //JC
            JC=1'b1;
        end
        else JC=1'b0;
        if (IR[7-:4]==4'b0010 && IR[3-:2]!=2'b11) begin //IN
            IN=1'b1;
        end
        else IN=1'b0;
        if (IR[7-:4]==4'b0100 && IR[3-:2]!=2'b11) begin //OUT
            OUT=1'b1;
        end
        else OUT=1'b0;
        if (IR[7:0]==8'b0111_0000) begin //NOP
            NOP=1'b1;
        end
        else NOP=1'b0;
        if (IR[7:0]==8'b1000_0000) begin //HALT
            HALT=1'b1;
        end
        else HALT=1'b0;
    end
    else begin
        MOVA=1'b0;
        MOVB=1'b0;
        MOVC=1'b0;
        ADD=1'b0;
        SUB=1'b0;
        AND=1'b0;
        NOT=1'b0;
        RSR=1'b0;
        RSL=1'b0;
        JMP=1'b0;
        JZ=1'b0;
        JC=1'b0;
        IN=1'b0;
        OUT=1'b0;
        NOP=1'b0;
        HALT=1'b0;
    end

end

endmodule //decoder

module decoder (EN,IR,MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT);
    input EN;
    input[7:0] IR;
    output MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
    reg MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
always @(IR,EN) begin
    if(EN==1'b1) begin
        if (IR[7-:4]==4'b1100) begin //MOV
            if(IR[3-:2]==2'b11) begin //MOVB 11R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
            else if (IR[1-:2]==2'b11) begin //MOVC R1111
                MOVA=1'b0;
                MOVB=1'b0;
                MOVC=1'b1;
            end
            else begin //MOVA R1R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
        end
        else begin
            MOVA=1'b0;
            MOVB=1'b0;
            MOVC=1'b0;
        end
        if (IR[7-:4]==4'b1001 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //ADD
            ADD=1'b1;
        end
        else ADD=1'b0;
        if (IR[7-:4]==4'b0110 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //SUB
            SUB=1'b1;
        end
        else SUB=1'b0;
        if (IR[7-:4]==4'b1011 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //AND
            AND=1'b1;
        end
        else AND=1'b0;
        if (IR[7-:4]==4'b0101 && IR[3-:2]!=2'b11) begin //NOT
            NOT=1'b1;
        end
        else NOT=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b00 && IR[3-:2]!=2'b11) begin //RSR
            RSR=1'b1;
        end
        else RSR=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b11 && IR[3-:2]!=2'b11) begin //RSL
            RSL=1'b1;
        end
        else RSL=1'b0;
        if (IR[7:0]==8'b0011_0000) begin //JMP
            JMP=1'b1;
        end
        else JMP=1'b0;
        if (IR[7:0]==8'b0011_0001) begin //JZ
            JZ=1'b1;
        end
        else JZ=1'b0;
        if (IR[7:0]==8'b0011_0010) begin //JC
            JC=1'b1;
        end
        else JC=1'b0;
        if (IR[7-:4]==4'b0010 && IR[3-:2]!=2'b11) begin //IN
            IN=1'b1;
        end
        else IN=1'b0;
        if (IR[7-:4]==4'b0100 && IR[3-:2]!=2'b11) begin //OUT
            OUT=1'b1;
        end
        else OUT=1'b0;
        if (IR[7:0]==8'b0111_0000) begin //NOP
            NOP=1'b1;
        end
        else NOP=1'b0;
        if (IR[7:0]==8'b1000_0000) begin //HALT
            HALT=1'b1;
        end
        else HALT=1'b0;
    end
    else begin
        MOVA=1'b0;
        MOVB=1'b0;
        MOVC=1'b0;
        ADD=1'b0;
        SUB=1'b0;
        AND=1'b0;
        NOT=1'b0;
        RSR=1'b0;
        RSL=1'b0;
        JMP=1'b0;
        JZ=1'b0;
        JC=1'b0;
        IN=1'b0;
        OUT=1'b0;
        NOP=1'b0;
        HALT=1'b0;
    end

end

endmodule //decoder

ALU

我之前想复杂了，完全不需要设计RCA，因为Cf指的 是最高位的进位或借位（即溢出），而不是逐位取进位或借位，所以可以直接使用拼接解决。 ~~怪不得从网上找了一堆资料没发现如何找借位~~

这样就没有之前那么难了，把ppt里的东西直接翻译出来就行了，源代码如下。

verilog

module ALU2 (M,S,A,B,t,Cf,Zf);
    input M;// 算术运算指示
    input [3:0] S;// 运算类型
    input [7:0] A,B;// 参与运算的数字

    output [7:0] t;// 输出结果
    output Cf,Zf;// 是否进位，是否为 0

    reg [7:0] t;
    reg Cf,Zf;
    reg [7:0] temp1;

    always @(M,S,A,B) begin
        if (M==1'b0) begin // 不进行算术运算
            if(S==4'b1100) t[7:0]=A[7:0];
            else t=8'b0;
            Cf=1'b0;
            Zf=1'b0;
        end
        else begin// 进行算术运算
            case (S)
                4'b1001: begin //ADD
                    {Cf,t}=A+B;
                    if (t==8'b0) begin
                        Zf=1'b1;
                    end
                    else Zf=1'b0;
                end
                4'b0110: begin //SUB
                    {Cf,t}=B-A;
                    if(t==8'b0) Zf=1'b1;
                    else Zf=1'b0;
                end
                4'b1011: begin //AND
                    // t=A&&B;
                    t[0]=A[0]&&B[0];
                    t[1]=A[1]&&B[1];
                    t[2]=A[2]&&B[2];
                    t[3]=A[3]&&B[3];
                    t[4]=A[4]&&B[4];
                    t[5]=A[5]&&B[5];
                    t[6]=A[6]&&B[6];
                    t[7]=A[7]&&B[7];
                    Cf=0;
                    Zf=0;
                end
                4'b0101: begin
                    t=~B; //NOT
                    Cf=0;
                    Zf=0;
                end
                4'b1010: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b0100: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b1100: begin
                    t=A;
                    Cf=0;
                    Zf=0;
                end
                default: begin
                    Cf=0;
                    Zf=0;
                    t=8'b0;
                end
            endcase
        end
    end
endmodule //ALU2

module ALU2 (M,S,A,B,t,Cf,Zf);
    input M;// 算术运算指示
    input [3:0] S;// 运算类型
    input [7:0] A,B;// 参与运算的数字

    output [7:0] t;// 输出结果
    output Cf,Zf;// 是否进位，是否为 0

    reg [7:0] t;
    reg Cf,Zf;
    reg [7:0] temp1;

    always @(M,S,A,B) begin
        if (M==1'b0) begin // 不进行算术运算
            if(S==4'b1100) t[7:0]=A[7:0];
            else t=8'b0;
            Cf=1'b0;
            Zf=1'b0;
        end
        else begin// 进行算术运算
            case (S)
                4'b1001: begin //ADD
                    {Cf,t}=A+B;
                    if (t==8'b0) begin
                        Zf=1'b1;
                    end
                    else Zf=1'b0;
                end
                4'b0110: begin //SUB
                    {Cf,t}=B-A;
                    if(t==8'b0) Zf=1'b1;
                    else Zf=1'b0;
                end
                4'b1011: begin //AND
                    // t=A&&B;
                    t[0]=A[0]&&B[0];
                    t[1]=A[1]&&B[1];
                    t[2]=A[2]&&B[2];
                    t[3]=A[3]&&B[3];
                    t[4]=A[4]&&B[4];
                    t[5]=A[5]&&B[5];
                    t[6]=A[6]&&B[6];
                    t[7]=A[7]&&B[7];
                    Cf=0;
                    Zf=0;
                end
                4'b0101: begin
                    t=~B; //NOT
                    Cf=0;
                    Zf=0;
                end
                4'b1010: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b0100: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b1100: begin
                    t=A;
                    Cf=0;
                    Zf=0;
                end
                default: begin
                    Cf=0;
                    Zf=0;
                    t=8'b0;
                end
            endcase
        end
    end
endmodule //ALU2

本文代码仿真所使用的波形文件可从此处获取，使用Quartus II 13.0 SP1生成。2021/12/06已更新本人验收用波形，数据较多。

湖大物理实验红黑榜

Sat, 23 Oct 2021 00:00:00 +0000

挑选几个我自己做过的大物实验（II），谈谈我的看法，希望能给后来者一点帮助。均为我本人做的时候的情况，仅供参考。

如果你有自己的见解，或者想为这篇文章补充，请评论，十分感谢您的贡献。

15 等厚干涉

强烈推荐，实验好做，数据好处理，报告好写，器材状态也比较好。

顺利的话，一般能在八点左右搞定，大部分数据处理也可以在八点半之前完成（八点半之前不能走）。大部分人都能在八点半之前完成实验任务。

18 夫琅和费衍射

另可参见评论区大佬建议

21 全息照相

一个几乎只需要写报告的实验，跟你做不做得出来没啥关系，因为一个周都不一定能有一组成功。不过也不要太摆烂，因为大家的实验进度是同步的，所有人都搭好光路才能继续下去（晚上做实验，大概八点半搭好，掐一下点）。

老师会额外留几道思考题，依据思考题答得好不好，来决定你实验的分数。

25 铁磁材料居里点的测量

可选。

建议带一个主动散热设备，包括但不限于手持风扇，能省很多事。

部分实验软件会闪退，我那台电脑的实验软件在快要完成的时候闪退了两次，如果看到记录册有写，做好手动记录的准备。

34 磁阻尼现象的实验研究

没有验证动量守恒了，只有磁阻尼。

实验操作有手就行，非常简单，估计很多同学甚至早已玩过气垫导轨了。

但实验操作一时爽，处理数据火葬场。数据非常多而且处理方法比较乱，非常费时间，如果你自认为没有足够的数据处理能力，不要选这个实验！！！！

反正我摸索着处理了将近一天，最后还是不会，信不信由你。

41 光拍法测量光速

非常推荐欧皇选择，因为 16 套器材有一半是坏的。即使你不是欧皇，也问题不大，仪器正常的人八点能走，之后用他们的仪器最晚八点半能走。

老师非常好，可能会帮你调实验仪器，也会允许多个人用一套器材。

数据不多，结果好算。

42 微波的基本特性研究

摘录一段记录在记录册上的话：“左右两边的数据不能说是一模一样，可以说是毫无关联了，这个实验唯一的优点也许是老师对实验数据毕竟包容叭”。

其他设备的干扰非常严重，到了可能改变你实验结果的程度。如果不介意等别人做完自己再做，以获得更好的实验数据，可选（雾，没有这么严重）。

迈克尔逊干涉实验的两个数据间大概相差 8-9。

CCF CSP 202109 @ HNU 游记

Sun, 19 Sep 2021 00:00:00 +0000

此处所指的是大学组的CSP，举行于2021年9月19日。

暴力出奇迹，骗分过样例。

暴搜挂着机，打表出省一。

NOIP名言

又是一年CSP时，抱着当年OI攒下的一点点老本，以 “过150就算赢” 为目标，本着暴力出奇迹的原则，参加了学校统一组织的考试。

关于考场

考场在湖南大学前进楼机房，设备可以说是很有年代感了。目测17寸左右的低分辨率显示器，2C2T的Pentium E5700 CPU，Windows 7，再搭配上Orwell Dev-C++ 5.11，整个简直像是上个时代的产物。由于远古的TDM-GCC 4.9.2、调用STL时的糟糕体验和层出不穷的bug，每次用Dev-C++ 调试，我都想打人…… 如果觉得Visual Studio Code不开源，哪怕装个VSCodium也好啊……

哦，顺便提一嘴，Orwell Dev-C++ 是有正统续作的，由Embarcadero开发，终于能用了：

Embarcadero/Dev-Cpp

Java环境好像也没有IntelliJ IDEA，Python好像也只能用IDLE，所以C++ 环境也不算差？

还行啦，CPU再烂也是独占的，起码比信息院机房的瘦客户机好用多了。

第一题

逐个输入，每个数都加入最大值，遇到比上个数大的就加进和的最小值。画图好理解。

第二题

先试了暴力方法，$p$ 从 $1$ 到 $10000$ 循环（没必要也千万不要把数改成 $0$），直接统计大于 $p$ 的数的区间数，70分，TLE三个点。

然后尝试搜索的思路，类似于暴力思路的改进，仍然是搜索大于p的区间数，但不会搜索整个数组，而是在上一个p所划分的区间内搜索。比如1 3 5 3 6 0 2 8，$p=1$ 时划出1 3 5 3 6和2 8，然后分别在这两个区间内继续搜索 $p=2$ 的情况即可。

误以为区间数是随 $p$ 先上升后下降的，试图用BFS控制搜索深度，幸亏BFS手生，没写完就发现并不是我想的那样（狗头保命），遂停止。

换用熟悉的DFS，结果仍然TLE三个点。原因是每次搜索，$p$ 的步进都是 $1$；事实上，仍然使用上个例子，$p=2$ 得到区间3 5 3 6，区间最小值是3，那么 $p=3$ 的区间数 + 1，然后直接搜索 $p=4$ 的情况即可，不必再搜索3的情况。

DFS优化完成后可以达到100分。

第三题

阅读理解越来越难了，做完前面的还剩2小时左右，估计读都读不完。

没做。

第四题

骗得20分。有20% 的数据，每个卡的爆率相同，易得期望就是 $n$。

还有20分比较简单，不知道为啥暴搜没过，5个牌还会T，真是……

第五题

瞄了一眼，似乎需要可持久化的数据结构，但有一个点没有操作2，也许可以暴力存储历史数据。即便如此还是没写出来，放弃了。

总结

暴搜流派yyds！

湖南大学 2021 程序设计训练笔记 - 作业训练 4

Mon, 06 Sep 2021 00:00:00 +0000

所有代码均已上传至 homework/CSP-Training at master · cyp0633/homework (github.com)。不保证代码均正确，正确的也不保证为最优解，可以查看Commit详情进一步了解。如无说明均用C++ 实现。

1. 在霍格沃茨找零钱

个人难度评级：2

问题描述

如果你是哈利 · 波特迷，你会知道魔法世界有它自己的货币系统 —— 就如海格告诉哈利的：“十七个银西可 (Sickle) 兑一个加隆 (Galleon)，二十九个纳特(Knut) 兑一个西可，很容易。”现在，给定哈利应付的价钱 $P$ 和他实付的钱 $A$，你的任务是写一个程序来计算他应该被找的零钱。

输入形式

输入在 $1$ 行中分别给出 $P$ 和 $A$，格式为 “Galleon.Sickle.Knut”，其间用 $1$ 个空格分隔。这里Galleon是 $[0, 10^7]$ 区间内的整数，Sickle是 $[0, 17)$ 区间内的整数，Knut是 $[0, 29)$ 区间内的整数。

输出形式

在一行中用与输入同样的格式输出哈利应该被找的零钱。如果他没带够钱，那么输出的应该是负数。

样例输入1

10.16.27 14.1.28

样例输出1

3.2.1

样例输入2

14.1.28 10.16.27

样例输出2

-3.2.1

解题思路

建议不要全部化为Knut再计算，直接对应相减然后借位即可。

本题一个坑，没带够钱的情况下，输出的数只有Galleon位有负号，实际上的意思是三个数都有负号，后面两个不需要输出。也就是说，” 样例输出2“的意义是找回 - 3 Galleon, -2 Sickle和 - 1 Knut。我建议的处理方式是，如果在借位之前最高位是负值，则将每一位取相反数，并输出一个负号，然后照常借位计算。

2. 最简单的计算机

个人难度评级：1

问题描述

一个名叫是 $PigHeadThree$ 的研究组织设计了一台实验用的计算机，命名为 $PpMm$。$PpMm$ 只能执行简单的六种命令 $A$，$B$，$C$，$D$，$E$，$F$；只有二个内存 $M1$，$M2$；三个寄存器 $R1$，$R2$，$R3$。六种命令的含义如下：
命令 $A$：将内存 $M1$ 的数据装到寄存器 $R1$ 中；
命令 $B$：将内存 $M2$ 的数据装到寄存器 $R2$ 中；
命令 $C$：将寄存器 $R3$ 的数据装到内存 $M1$ 中；
命令 $D$：将寄存器 $R3$ 的数据装到内存 $M2$ 中；
命令 $E$：将寄存器 $R1$ 中的数据和寄存器 $R2$ 中的数据相加，结果放到寄存器 $R3$ 中；
命令 $F$：将寄存器 $R1$ 中的数据和寄存器 $R2$ 中的数据相减，结果放到寄存器 $R3$ 中。
你的任务是：设计一个程序模拟 $PpMm$ 的运行。

输入形式

有若干组，每组有 $2$ 行，第一行是 $2$ 个整数，分别表示 $M1$ 和 $M2$ 中的初始内容；第二行是一串长度不超过 $200$ 的由大写字母 $A$ 到 $F$ 组成的命令串，命令串的含义如上所述。

输出形式

对应每一组的输入，输出只有一行，二个整数，分别表示 $M1$，$M2$ 的内容；其中 $M1$ 和 $M2$ 之间用逗号隔开。

样例输入

100 288
ABECED
876356 321456
ABECAEDBECAF

样例输出

388,388
2717080,1519268

解题思路

果然是最简单的…… 什么，你不会switch语句都不会用吧？

3. 相同生日

个人难度评级：2

问题描述

在一个有 $n$ 个人的大班级中，存在两个人生日相同的概率非常大，现给出每个学生的学号，出生月日，试找出所有生日相同的学生。

输入形式

第一行为整数 $n$，表示有 $n$ 个学生，$n \le 200$。此后每行包含一个字符串和两个整数，分别表示学生的学号 (字符串长度为 $11$ 位) 和出生月 $(1 \le m \le 12)$ 日 $(1 \le d \le 31)$，学号、月、日之间用一个空格分隔。

输出形式

对每组生日相同的学生，输出一行，其中前两个数字表示月和日，后面跟着所有在当天出生的学生的学号，数字、学号之间都用一个空格分隔。对所有的输出，要求按日期从前到后的顺序输出。对生日相同的学号，按输入的顺序输出。

样例输入

6
07101020105 3 15
07101020115 4 5
07101020118 3 15
07101020108 4 5
07101020111 4 5
07101020121 8 10

样例输出

3 15 07101020105 07101020118
4 5 07101020115 07101020108 07101020111
8 10 07101020121

解题思路

建立 vector<string> birthday[13][32]，然后将对应生日的同学之间 push_back 进对应日期的 vector 即可。要求同日期按输入顺序输出，不需 priority_queue 之类。虽学号是数字但不能直接用 long long，当然你输出保留11位，前面补0也可以，主要就是前导0的问题。

4. 日历问题

个人难度评级：3

问题描述

在我们现在使用的日历中, 闰年被定义为能被 $4$ 整除的年份，但是能被 $100$ 整除而不能被 $400$ 整除的年是例外，它们不是闰年。例如：$1700$, $1800$, $1900$ 和 $2100$ 不是闰年，而 $1600$, $2000$ 和 $2400$ 是闰年。给定从公元 $2000$ 年 $1$ 月 $1$ 日开始逝去的天数，你的任务是给出这一天是哪年哪月哪日星期几。

输入形式

输入包含若干行，每行包含一个正整数，表示从 $2000$ 年 $1$ 月 $1$ 日开始逝去的天数。输入最后一行是 $-1$, 不必处理。可以假设结果的年份不会超过 $9999$。

输出形式

对每个测试样例，输出一行，该行包含对应的日期和星期几。格式为 “YYYY-MM-DD DayOfWeek”, 其中 “DayOfWeek” 必须是下面中的一个： “Sunday”, “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday” and “Saturday“。

样例输入

样例输出

2004-09-26 Sunday
2004-10-06 Wednesday
2004-10-16 Saturday
2004-10-17 Sunday

解题思路

这个题结合代码看得更明白。

打表，建立五个数组，内容如下：

$[2000,9999]$ 年范围内，每一年的最后一天是1999年12月31号之后的第几天，即只需计算每年天数的前缀和；
$[2000,9999]$ 年范围内，每一年是否是闰年（这个不要用 true 或者 false 表示，否则代码会超过100KB而无法提交）；
闰年中，每一个月的最后一天是上一年12月31日之后第几天，即每个月天数的前缀和；
平年中，同上；
天数模7，每个余数所对应最后日期的星期，第1个值不是 Monday 也不是 Sunday，而是 Saturday（2000/01/01就是周六，过7的倍数天还是周六）。

首先模7算完星期之后，要将输入的天数 + 1，转换为”2000年1月1日起的第几天 “。

然后枚举第一个数组，如果某个年份（减2000）对应的值大于等于天数，则该年份就是所求日期年份。从天数中减掉数组中上一年对应的值（2000年不用），得到所求日期是这一年的第几天。如果天数减为0，则赋给它本年天数值（当然，直接输出12月31日也未尝不可）。

分是否闰年，枚举第三 / 四个数组，以和上面相似的方式确定月份。自然也就很容易得到日期。

格式化输出中，使用 %02d，输出整型并在不足2位的时候补0。

5. 小希的数表

个人难度评级：4

问题描述

Gardon昨天给小希布置了一道作业，即根据一张由不超过 $5000$ 的 $N$ $(3 \le N \le 100)$ 个正整数组成的数表两两相加得到 $N*(N-1)/2$ 个和，然后再将它们排序。例如，如果数表里含有四个数 $1$，$3$，$4$，$9$，那么正确答案是 $4$，$5$，$7$，$10$，$12$，$13$。小希做完作业以后出去玩了一阵，可是下午回家时发现原来的那张数表不见了，好在她做出的答案还在，你能帮助她根据她的答案计算出原来的数表么？

输入形式

包含多组数据，每组数据以一个 $N$ 开头，接下来的一行有按照大小顺序排列的 $N*(N-1)/2$ 个数，是小希完成的答案。文件最后以一个 $0$ 结束。
假设输入保证解的存在性和唯一性。

输出形式

对于每组数据，输出原来的数表。它们也应当是按照顺序排列的。

样例输入

4
4 5 7 10 12 13
4
5 6 7 8 9 10
0

样例输出

1 3 4 9
2 3 4 6

解题思路

设 $a$ 为原数字列表，$s$ 为和的列表。

首先，由于 $s_i$ 和 $a_i$ 是从小到大排列的，反证法易证 $s_1=a_1+a_2$，$s_2=a_1+a_3$。然而 $s_3$ 并不一定是 $a_2+a_3$，而很可能是 $a_1+a_4$ 等。由此，我们需要枚举 $s_3$ 到 $s_{(n-1)*n/2}$，对于每一个 $s_i$，结合 $s_1$ 和 $s_2$，解出 $a_1$、$a_2$ 和 $a_3$，当它们均为正整数的时候才可能符合条件，能够往下进行。符合这里条件的 $a_2+a+_3$ 可能有多组，可能在后续步骤中会毙掉几组。

然后，我们只需要找出 $s_j=a_1+a_i$，就可以算出 $a_i$。因为 $a_1$ 最小，所以 $s_j$ 排在较靠前的位置，比较好找。比如现在我们要找 $a_1+a_4$，如果将 $a_1$、$a_2$ 和 $a_3$ 两两组合算出和，然后将这些和从 $s$ 中剔除，那么可以证明 $a_1+a_4$ 就是剩下的当中最小的一个和，也就能比较容易地从 $s$ 中找出。当然，仍然要检验 $a_4$ 乃至后面所有的 $a_i$ 是不是正整数。

现在我们找到了 $a_4$，那么该怎么找到 $a_5$ 乃至后面的数呢？我们可以仿照前面的方法，将前面已求出的数两两组合求和，将结果存入一个 set 中（毕竟剔除工作比较复杂）。在遍历每个 $s$ 的时候，如果 $s_i$ 的值处在该set中，则跳过。否则，这个值就是 $a_1+a_{j}$，$j$ 是已经确定的 $a$ 数量。然后，将这个 $a_j$ 分别与前面的 $a$ 相加，存入set，就可以及时维护这个set。

所有 $a$ 的值都确定完成，你以为就得出解了吗？早着呢，这样你会WA掉测试点3、4、5、6和7。刚刚我们所求出的这套解，并不一定能满足题目的条件，也就是加出后面的和。既然已经假定所有的 $a$ 已经解出并符合题目要求，那么set中理应出现测试数据给出的所有的 $s_i$。继续遍历，对后面的每一个 $s_i$，都查找它是否在set中。如果不在，那么这组 $a$ 就不是符合条件的解，再取一个 $a_2+a_3$ 吧……

你兴致勃勃地将代码交了上去，发现只解决了7。不同的 $a_i+a_j$ 组合可以得出相同的两个 $s$ 值。这时候再用set就明显不合适了，可以考虑使用同一个键值允许出现多次的set——multiset，同时将已经在 $s$ 中出现的和删除。很容易想到使用multiset的 erase 函数处理，但这个函数有多个重载，如果传入一个键值，它会删除该键值的 ** 所有 ** 元素。而如果传入一个指针 / 迭代器，就只会删除指向的这一个元素。我们的需求是出现一次删除一次，那当然要传入迭代器。

6. 数塔

个人难度评级：2

问题描述

给定一个数塔，如下图所示。在此数塔中，从顶部出发，在每一节点可以选择走左下或右下，一直走到底层。请找出一条路径，使路径上的数值和最大。

				9
			12		15
		10		6		8
	2		18		9		5
19		7		10		4		16

输入形式

输入时第一行一个整数 $n$，表示该数塔的行数，其余 $n$ 行表示该塔每行的数值

输出形式

输出包含两行，第一行为最大路径上的数值之和，第二行 $n$ 个数字为从上而下最大路径数值

样例输入

5
9
12 15
10 6 8
2 18 9 5
19 7 10 4 16

样例输出

59
9 12 10 18 10

解题思路

一道标准的搜索题，可以DFS也可以BFS，搜索过程中传递行号、列号、当前路径长度和用vector存储的完整路径。

7. 斯诺克台球（不做了）

个人难度评级：6

问题描述

斯诺克台球是一项古老而又时尚的运动，使用长方形球桌，台面四角以及两长边中心位置各有一个球袋，使用的球分为1个白球，15个红球和6个彩球共22个球。

其中母球（白球）1只，目标球21只。目标球中：红球15只各1分、黄球1只2分、绿球1只3分、咖啡球1只4分、蓝球1只5分、粉球1只6分、黑球1只7分。

选手需要使用球杆撞击母球去击打目标球来完成得分，每局开始时总是先从红球开始。击球顺序为先打进红球（每次击打允许多个红球同时落袋），然后必须任意指定一个目标彩球击打，如果该彩球被打进（打进后需要再摆回），然后接着击打红球，直到红球全部落袋，然后以黄、绿、咖啡、蓝、粉红、黑的顺序逐个击球（不再摆回），最后以得分高者为胜。任何时候红球落袋都不再摆回，任何时候因犯规导致彩球落袋，彩球必须摆回。

斯诺克比赛由双方轮流击打，必须击打合规的目标球，打进则本方得到相应的分数并继续击打，未打进或犯规轮换为对方击打，未打进不得分，犯规将进行罚分处理。

犯规规则如下：

1. 当击打目标球时，如果先击打到或同时击打到一个或多个其他颜色的球，或者有其他颜色的球落袋，或者打空 (未击打到任何球)，则视为犯规。此时需要比较目标球的分值和与本犯规相关的其他颜色的球的分值，取其中最高的分值，如果该分值小于4，则对方加4分，否则对方加该分值。

2. 当击打红球落袋后，继续击打任意彩球时打空，即未打击到任何球，对方加4分。

相比正式的斯诺克比赛，本问题对规则进行了简化，任何时候都可以结束比赛并计算比赛结果，不考虑白球落袋的情况。

信息化时代的智能台球桌能自动记录实际比赛时的击打记录，并传送到后台，但该记录仅仅是流水记录，并且无参赛选手的任何信息，需要你编程计算每场比赛的比分，同时需要计算单杆100分及以上的情况（单杆得分是指选手一次连续击打所得分数之和）。

输入形式

输入第一行为正整数 $t$ $(t \le 100)$，表示有 $t$ 组测试数据，每组数据代表一局比赛。

在输入中，球的颜色表示为：

**r - 红色球 y - 黄色球 g - 绿色球 c - 咖啡色球 b - 蓝色球 p - 粉红球 B - 黑色球 **

接下来的每组数据包括若干行，每一行为一次击打的结果，为智能球桌记录下来的流水记录，每组数据最后一行为 - 1，表示每组数据的结束。

流水记录包含用空格分隔的2个部分：

首先撞到的球落袋球及数量

第一部分 “首先撞到的球” 为一个字符串，可以是 “rygcbpB” 中1个或多个字符组合（可能有多个字符 “r”）, 或为字符串“$NULL$”。为“$NULL$” 时，第二部分必为空，表示该次击打未撞击到任何球也没有任何球落袋。当红球落袋后继续击打任意彩球时，该部分为 “ygcbpB” 中的任意单个字符时都认为是合规的目标球。

第二部分 “落袋球及数量” 为一个字符串，例如“r2gb”，代表本次击打有两个红球落袋，以及绿球和篮球落袋，红色球r后面有数字（大于 $0$ 小于 $16$），表示红球的落袋数，其他彩球后无数字。该部分可以为空，表示本次击打无球落袋。

比赛在 $A$ 与 $B$ 之间进行，每局比赛总是由 $A$ 先开球。

输出形式

输出为 $t+1$ 行，前 $t$ 行每行输出用冒号分隔的两个整数，表示每局比赛 $A$ 与 $B$ 之间的比分；最后一行输出用冒号分隔的两个整数，表示 $t$ 局比赛之后 $A$ 与 $B$ 之间获得的单杆 $100$ 分及以上的次数之比（单杆得分是指选手一次连续击打所得分数之和）。

样例输入

3
r r1
B
r r2
c c
r r1
b g
-1
rp r1
r br2B
NULL
r r12
y y
g p
-1
rr r3
NULL
r r1
yg y
-1

样例输出

6:7
13:24
7:5
0:0

样例说明

第一局比赛：

A击打红球，打进1个红球，得1分，比分为1:0

A继续击打任意彩球，打到黑球，未打进，不得分，比分为1:0

轮换为B击打红球，打进两个红球，得2分，比分为1:2

B继续击打任意彩球，打到咖啡球，打进咖啡球，咖啡球摆回，得4分，比分为1:6

B继续击打红球，打进一个红球，得1分，比分为1:7

B继续击打任意彩球，打到蓝球，打进绿球，犯规，取分值最大者蓝球，绿球摆回，对方加5分，比分为6:7

-1比赛结束

第二局比赛：

A击打红球，首先打到红球和粉球，犯规，打进1个红球和咖啡球，犯规，咖啡球摆回，取分值最大的粉球，对方加6分，比分为0:6

B击打红球，首先打到红球，打进蓝球、2个红球和黑球，犯规，蓝球和黑球摆回，取分值最大的黑球，对方加7分，比分为7:6

A击打红球，未打到任何球，犯规，对方加4分，比分为7:10

B击打红球，打到红球，打进12个红球，加12分，比分为7:22

B击打任意彩球，打到黄球，打进黄球，黄球摆回，得2分，比分为7:24

B击打黄球，打到绿球，打进粉球，犯规，粉球摆回，对方加6分，比分为13:24

-1比赛结束

第三局比赛：

A击打红球，打到2个红球，打进3个红球，加3分，比分为3:0

A击打任意彩球，打空，未打到任何球，对方加4分，比分为3:4

B击打红球，打到1个红球，打进1个红球，加1分，比分为3:5

B击打任意彩球，打到黄球和绿球，打进黄球，犯规，黄球摆回，取分值最高的绿球，绿球分值小于4，对方加4分，比分为7:5

-1比赛结束

3局比赛中无人单杆得分过100，最后一行输出0:0

解题思路

大模拟做他🐎呢，笑死，根本做不出来😅

8. 最少钱币数

个人难度评级：4

问题描述

这是一个古老而又经典的问题。用给定的几种钱币凑成某个钱数，一般而言有多种方式。例如：给定了6种钱币面值为2、5、10、20、50、100，用来凑15元，可以用5个2元、1个5元，或者3个5元，或者1个5元、1个10元，等等。显然，最少需要2个钱币才能凑成15元。
你的任务就是，给定若干个互不相同的钱币面值，编程计算，最少需要多少个钱币才能凑成某个给出的钱数。

输入形式

输入可以有多个测试用例。每个测试用例的第一行是待凑的钱数值 $M$ $(1 \le M \le 2000，整数)$，接着的一行中，第一个整数 $K$ $(1 \le K \le 10)$ 表示币种个数，随后是 $K$ 个互不相同的钱币面值 $K_i$ $(1 \le K_i \le 1000)$。输入 $M=0$ 时结束。

输出形式

每个测试用例输出一行，即凑成钱数值 $M$ 最少需要的钱币个数。如果凑钱失败，输出 “Impossible”。你可以假设，每种待凑钱币的数量是无限多的。

样例输入

156 2 5 10 20 50 10011 20

样例输出

2Impossible

解题思路

DP题，有点像完全背包。参考了最少钱币数（DP）_Salmon_lee 的博客 - CSDN 博客。

这道题的最优子结构性质是，可以先得出用前 $i$ 种面值得出 $j$ 元以内的最少钱币数。使用前 $i$ 种面值组合成 $j$ 元的最少钱币数，是 “使用前 $i-1$ 种面值组合成 $j$ 元的最少钱币数” 与“使用前 $i$ 种面值组合成 $j-val$ 元的最少钱币数 + 1，$val$ 为第 $j$ 种钱币的面值”的较小值，即状态转移方程：$dp_{i,j}=min(dp_{i-1,j},dp_{i,j-val})$。两层循环，第一层循环遍历各种面值的钱币，第二层循环遍历各种金额，均为从前往后遍历。二维DP示例代码在这里。

那么可不可以压缩成一维呢？自然可以，将前i种面值的这一维压掉。状态转移方程变为 $dp_i=min(dp_i,dp_{i-val})$。

注意多组数据，dp数组需要memset多次。

9. 相等的多项式

个人难度评级：2

问题描述

小明现在在学习多项式的展开：就是把一个形如

$(x+a_1)(x+a_2)…(x+a_n)$

展开成如下形式：

$x^n+b_1x^{n-1}+b_2x^{n-2}+…+b_{n-1}x+b_n$

比如 $(x+1)(x+2)=x^2+3x+2$

$(x+1)^3=x^3+3x^2+3x+1$

小明做了很多练习，但是不知道对错，现在请求你的帮助，判断小明的展开式是否正确。

输入格式

有多组测试数据。

每组测试数据有三行，第一行是一个正整数 $N$，表示多项式最高指数。$N=0$ 表示输入结束，并且不需要处理。

第二行N个整数ai，用空格隔开，$i=1，…,N(-100 \le a_i \le 100)$

第三行N个整数bi，用空格隔开，$i=1，…,N，(-10^9 \le b_i \le 10^9)$

40% 的测试数据 $1 \le N < 5$；

30% 的测试数据 $5 \le N < 10$；

20% 的测试数据 $10 \le N < 15$；

10% 的测试数据1$5 \le N \le 20$；

输出格式

　　对于每组测试数据，输出一行一个字符‘Y’ 如果展开式是正确的，输出‘N’如果展开式错误。

样例输入

样例输出

Y
Y
N

解题思路

如果还记得二项式定理，这道题会好做很多。使用DFS，对每个因式分别选择乘上字母或者数字，边界条件为选择完所有因式，此时将该次数的因子加到结果多项式的数组对应项即可。

题目输入的多项式是按次数由大到小排的，由 $n-1$ 到 $0$，而我们乘出的多项式数组应该反向与它比较。

10. 选美比赛

个人难度评级：1

问题描述

在选美大奖赛的半决赛现场，有 $n$ 名选手 $(2<n<100)$ 参加比赛。比赛结束时，要在现场按照选手的出场顺序宣布最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。如：

选手数量： 7

选手得分： 5，3，4，7，3，5，6

宣布名次： 3，5，4，1，5，3，2

请编程帮助大奖赛组委会完成半决赛的评分排名工作。

输入形式

选手数量：7

选手得分：5 3 4 7 3 5 6

输出形式

选手的排名：3 5 4 1 5 3 2

样例输入

7
5 3 4 7 3 5 6

样例输出

3 5 4 1 5 3 2

样例说明

本题的关键在于如何处理同分数的选手排名问题

解题思路

用结构体存储选手，内含编号、得分和排名三个成员变量。

输入得分顺便指定编号，按照得分降序sort一遍，赋给排名（注意：即使有多个第 $n$ 名并列，排在这些后面的仍然是 $n+1$ 名），然后再按照编号升序sort，输出即可。

11. 蛇行矩阵

个人难度评级：2

问题描述

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形

输入形式

正整数N表示层数，N不大于100

输出形式

输出一个N行的蛇形矩阵，矩阵三角中同一行的数字用一个空格分开，行尾不要多余的空格。

样例输入

样例输出

1 3 6 10 152 5 9 144 8 137 1211

解题思路

首先构建第一列。容易观察得到，上下相邻的两个值有关系 $a_{i,1}=a_{i-1,1}+i-1 (2 \le i \le n)$。要是我还在上高中，也许能算出通项公式，但现在不一定了

然后对于每一行，根据第一列构建剩下的列，根据关系 $a_{i,j}=a_{i,j-1}+i+j-1(1 \le i \le n, 2 \le j \le n-i+1)$。

没必要真按照蛇形去构建，按照上面的方法可以直接打个表交上去，虽然完整的重新构建也不会超时就是了。

12. 疫情期间

个人难度评级：3 | TLE了测试点1

问题描述

正值新冠疫情期间，阿迪没法返回学校学习，他希望通过参加一些比赛来提高一下编程技能，同时做做运动。他收集了接下来的 $n$ 天里每一天的信息，包括健身房是否开放，或者互联网上是否有程序设计竞赛。

第 $i$ 天可以有以下四种情况之一：

该天健身房不开放，互联网上也没有竞赛
该天健身房不开放，但互联网上有竞赛
该天健身房开放，但互联网上没有竞赛
该天健身房开放，互联网上也有竞赛

每天阿迪要么休息，要么编写程序（如果该天有竞赛），要么做运动（如果该天健身房开放）。

现在有一个限制条件：不能连续两天都去做运动，或者连续两天都编写程序。阿迪对自己要求很高，希望尽量多写程序或者多做运动，使得休息的天数尽量最少，求出这个天数。

输入形式

输入的第一行为一个正整数 $n(1 \le n \le 100)$，表示接下来的天数。

第二行为一个用空格分隔的整数序列 $a_1$、$a_2$、…、$a_n$ $(0 \le a_i \le 3)$，这里

$a_i=0$，第 $i$ 天健身房不开放，互联网上也没有竞赛
$a_i=1$，第 $i$ 天健身房不开放，但互联网上有竞赛
$a_i=2$，第 $i$ 天健身房开放，但互联网上没有竞赛
$a_i=3$，第 $i$ 天健身房开放，互联网上也有竞赛

输出形式

输入阿迪可能休息的最小天数。注意限制条件：

不能连续两天去做运动
不能连续两天编写程序

样例输入1

4
1 3 2 0

样例输出1

样例输入2

7
1 3 3 2 1 2 3

样例输出2

样例输入3

2
2 2

样例输出3

样例说明

在第一个样例中，阿迪在第一天编写程序，在第三天做运动，因此他仅有两天可以休息。

在第二个样例中，阿迪可以在第1、3、5、7天编写程序，其他天做运动，因此没有哪天休息。

在第三个样例中，阿迪可以在第1天或第2天做运动，但不能连续两天运动，因此他有一天休息。

解题思路

暴搜90分。DFS传入天数、休息次数和上一天的行为，分为编程、运动和休息三种情况即可。

其实90分也不错了，对吧？

13.7，还是7

个人难度评级：1

问题描述

输出7和7的倍数，还有包含7的数字例如（17，27，37…70，71，72，73…）

输入形式

一个正整数 $N$。($N$ 不大于 $30000$)

输出形式

从小到大排列的不大于N的与7有关的正整数，每行一个。

样例输入

样例输出

解题思路

可以结合 to_string 和字符串 find 函数来找包含7的数字。

14. 组个最小数

个人难度评级：1

问题描述

给定数字0-9各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意0不能做首位）。例如：给定两个0，两个1，三个5，一个8，我们得到的最小的数就是10015558。

现给定数字，请编写程序输出能够组成的最小的数。

输入形式

每个输入包含1个测试用例。每个测试用例在一行中给出多个（不超过50个）数字（0~9之间），整数间用一个空格分隔，且至少拥有1个非0的数字。

输出形式

在一行中输出能够组成的最小的数。

样例输入

2 2 0 0 0 3 0 0 1 0

样例输出

1000000223

解题思路

输入时统计每个数出现次数，先输出一个非零数，然后剩下的从小到大输出。

15. 字频统计

个人难度评级：2

问题描述

在一个只有字母’a’ 和’b’ 组成的字符串中，统计子串 “ab” 和 “ba” 出现次数的差。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示字符串长度，接下来一行是长度为 $N$ 的字符串，字符串中只有字母’a’ 和’b’。

$N=0$ 表示输入结束，并且不需要处理。

$40%$ 的数列元素个数 $N$ $1 \le N \le 100$；

$30%$ 的数列元素个数 $N$ $1 \le N \le 1000$；

$20%$ 的数列元素个数 $N$ $1 \le N \le 10000$；

$10%$ 的数列元素个数 $N$ $1 \le N \le 100000$；

输出格式

　　对于每组测试数据，输出一个整数：“ab” 和 “ba” 出现次数的差。

样例输入

7
aaaaaaa
4
abab
0

样例输出

0
1

解题思路

这个似乎用不了字符串的 find 成员函数，那就自己写呗。每个字符串遍历两遍，找就行了。

16. 逆序数

个人难度评级：1

问题描述

在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。也就是说，对于 $n$ 个不同的元素，先规定各元素之间有一个标准次序（例如 $n$ 个不同的自然数，可规定从小到大为标准次序），于是在这 $n$ 个元素的任一排列中，当某两个元素的先后次序与标准次序不同时，就说有 $1$ 个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。

比如：

数列1 7 3 5 4 8 9

其中 $(7,3)$，$(7,5)$，$(7,4)$，$(5,4)$ 构成逆序，所以其逆序数为 $4$。

对给定的数列，求出其逆序数。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示数列中元素个数，接下来一行 $N$ 个用空格分隔开的正整数，表示数列的 $N$ 个元素，数列元素值小于 $32768$，并且一个数列中没有两个数值相同。

$N=0$ 表示输入结束，并且不需要处理。

$40%$ 的数列元素个数 $N$ $1 \le N \le 10$；

$30%$ 的数列元素个数 $N$ $1 \le N \le 100$；

$20%$ 的数列元素个数 $N$ $1 \le N \le 1000$；

$10%$ 的数列元素个数 $N$ $1 \le N \le 5000$；

输出格式

　　对于每组测试数据，输出一个整数：数列的逆序数。

样例输入

7
1 7 3 5 4 8 9
4
1 2 3 4
0

样例输出

4
0

解题思路

两层循环枚举组合解决。

17. 最小钱币数（贪心算法）

个人难度评级：1

问题描述

阿迪有很多钱。他在银行里有n元。出于安全考虑，他想用现金取款（此处不透露原因）。钞票的面额是1，5，10，20，100元。取出全部余额后能收到的最小钞票数是多少？

输入形式

输入一个正整数 $n$，$(1 \le n \le 10^9)$

输出形式

阿迪能收到的最小钞票数

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

1000000000

样例输出3

10000000

样例说明

本题可以直接使用贪心策略（优先尽可能多选择大面额的钞票）解决：主要原因是后一个的权值（这里就是纸币面值）是前一个的2倍或以上。

可以思考一下如果货币的类型是1,9,10元三种，要求凑出18元，你可能就会发现贪心算法出错了！

解题思路

上面说得这么明白了我还说啥啊，这题没了DP就没了灵魂了。

18. 身份证校验

个人难度评级：1

问题描述

我国国标〖GB 11643-1999〗中规定：公民身份号码是18位特征组合码，由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。其校验码 (最后一位) 计算方法和步骤为：

(1) 十七位数字本体码加权求和公式

$S = sum(A_i * W_i), i = 0, … , 16$ ，先对前17位数字的权求和

其中 $A_i$：表示第i位置上的身份证号码数字值

$W_i$：表示第i位置上的加权因子，前17位加权因子从左到右分别为

$W_i$：7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2

(2) 计算模

$Y = mod(S, 11)$

(3) 通过模Y查下表得到对应的校验码

$Y$	0	1	2	3	4	5	6	7	8	9	10
校验码	1	0	X	9	8	7	6	5	4	3	2

例如：某身份证前17位为11010519491231002

$i$	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
$W_i$	7	9	10	5	8	4	2	1	6	3	7	9	10	5	8	4	2
	1	1	0	1	0	5	1	9	4	9	1	2	3	1	0	0	2
积	7	9	0	5	0	20	2	9	24	27	7	18	30	5	0	0	4

得到和为：167；则模为 $y=167%11=2$

查 (3) 得校验码为X（大写）

请按上面所述步骤编程，输入一个二代身份证号，检查该身份证是否正确。

输入形式

输入若干行，每行一个身份证号码，最后一行输入 - 1

输出形式

输出1代表正确，0代表错误

样例输入

120223198902021249
130132199210293822
130402198207290622
-1

样例输出

1
1
0

解题思路

如果会用 std::map，可以将校验码和余数对应，很方便。写一堆if倒也不是不能做。

18. 最长递增子序列

个人难度评级：2

问题描述

给出一个由 $n$ 个正整数组成的数组。您的任务是找到给定数组的递增子数组的最大长度。

递增子数组由数组中若干个连续元素组成，且子数组中的每个元素严格地大于前一个元素。

输入形式

第一行为一个正整数 $n(1 \le n \le 10^5)$，表示数组元素的个数

第二行给出 $n$ 个正整数 $a_1$ $a_2$……$a_n$ $(1 \le a_i \le 10^9)$ ，整数之间使用空格分隔

输出形式

输出最大递增子数组的长度

样例输入

5
1 7 2 11 15

样例输出

样例说明

1 7可以构成一个递增子数组

2 11 15可以构成一个递增子数组

所以本样例的输出结果为3

解题思路

贪心。遍历一遍，有递增的就计数，不递增了就重置。

20.Caesar密码

个人难度评级：1

问题描述

Julius Caesar生活在充满危险和阴谋的年代。为了生存，他首次发明了密码，用于军队的消息传递。假设你是Caesar军团中的一名军官，需要把Caesar发送的消息破译出来、并提供给你的将军。消息加密的办法是：对消息原文中的每个字母，分别用该字母之后的第5个字母替换（例如：消息原文中的每个字母A都分别替换成字母F），其他字符不变，并且消息原文的所有字母都是大写的。密码字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z原文字母：V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

输入形式

最多不超过100个数据集组成。每个数据集由3部分组成：起始行：START密码消息：由1到200个字符组成一行，表示Caesar发出的一条消息结束行：END在最后一个数据集之后，是另一行：ENDOFINPUT

输出形式

每个数据集对应一行，是Caesar的原始消息。

样例输入

START
NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX
END
START
N BTZQI WFYMJW GJ KNWXY NS F QNYYQJ NGJWNFS ANQQFLJ YMFS XJHTSI NS WTRJ
END
START
IFSLJW PSTBX KZQQ BJQQ YMFY HFJXFW NX RTWJ IFSLJWTZX YMFS MJ
END
ENDOFINPUT

样例输出

IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES
I WOULD RATHER BE FIRST IN A LITTLE IBERIAN VILLAGE THAN SECOND IN ROME
DANGER KNOWS FULL WELL THAT CAESAR IS MORE DANGEROUS THAN HE

解题思路

推荐使用getline函数输入数据，一次输入是一整行。

没必要前面提到的 std::map，因为这个太有规律了，对于大写字母，ASCII直接减5，如果小于’A’ 再加26即可。

21. 回文串

问题描述

“回文串”是一个正读和反读都一样的字符串，比如 “level” 或者 “noon” 等等就是回文串。给你一个字符串，问最少在字符串尾添加多少字符，可以使得字符串变为回文串。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示字符串长度，接下来一行是长度为N的字符串，字符串中只有小写字母。

$N=0$ 表示输入结束，并且不需要处理。

$40 % $ 的数列元素个数 $N$ $1 \le N \le 100$；

$30 % $ 的数列元素个数 $N$ $1 \le N \le 1000$；

$20 % $ 的数列元素个数 $N$ $1 \le N \le 10000$；

$10 % $ 的数列元素个数 $N$ $1 \le N \le 100000$；

输出格式

　　对于每组测试数据，输出一个非负整数：添加最少的字符数，可以使得字符串变为回文串。

样例输入

3
aba
4
aaac
0

样例输出

0
3

解题思路

参考了 HNU 软件能力实训 4-21. 回文串 _Karltan 的博客 - CSDN 博客。

对于每个字符串，逐个截取前1、2、3…… 到N位并反转，连接到原串后面，然后检验是否为回文串即可。

熟练运用STL会让这道题非常简单（主要是 reverse 和 substr）。

湖南大学 2021 程序设计训练笔记 - 作业训练 3

Mon, 12 Jul 2021 00:00:00 +0000

所有代码均已上传至 homework/CSP-Training at master · cyp0633/homework (github.com)。不保证代码均正确，正确的也不保证为最优解，可以查看Commit详情进一步了解。

1. 部分A+B

个人难度评级：1

问题描述

正整数A的 “DA（为1位整数）部分” 定义为由A中所有DA组成的新整数PA。例如：给定A = 3862767，DA = 6，则A的“6部分”PA是66，因为A中有2个6；给定A = 3862767，DA = 1，则A的“1部分”PA是0，因为A中有0个1。

现给定A、DA、B、DB，请编写程序计算PA + PB。

输入形式

输入在一行中依次给出A、DA、B、DB，中间以空格分隔，其中0 < A, B < 1010。

输出形式

在一行中输出PA + PB的值。

样例输入

3862767 6 13530293 3

样例输出

解题思路

这个题都不会的话建议去面壁…… 没开long long导致WA掉的话情有可原。

2. 导弹拦截系统

来源：NOIP 1999普及组不知道第几题（洛谷 P1020）（有改动）

个人难度评级：3

问题描述

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

输入形式

每组输入有两行，

第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），

第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。

输出形式

每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

样例输入

8
300 207 155 300 299 170 158 65

样例输出

解题思路

贪心就完事了，建议去翻洛谷的题解，那个更难，但估计讲得比我明白。

本题数据很弱，开O(n2) 的算法完全能过。

3. 魔咒词典

来源：HDU 1880（无法访问可移步 Vjudge）

个人难度评级：2

问题描述

哈利波特在魔法学校的必修课之一就是学习魔咒。据说魔法世界有100000种不同的魔咒，哈利很难全部记住，但是为了对抗强敌，他必须在危急时刻能够调用任何一个需要的魔咒，所以他需要你的帮助。

给你一部魔咒词典。当哈利听到一个魔咒时，你的程序必须告诉他那个魔咒的功能；当哈利需要某个功能但不知道该用什么魔咒时，你的程序要替他找到相应的魔咒。如果他要的魔咒不在词典中，就输出 “what?”

输入形式

首先列出词典中不超过100000条不同的魔咒词条，每条格式为：

[魔咒 ] 对应功能

其中 “魔咒” 和“对应功能”分别为长度不超过20和80的字符串，字符串中保证不包含字符 “[” 和“]”，且 “]” 和后面的字符串之间有且仅有一个空格。词典最后一行以 “@END@” 结束，这一行不属于词典中的词条。
词典之后的一行包含非负整数N（0=<N<=1000），随后是N个测试用例。每个测试用例占一行，或者给出 “[魔咒 ]”，或者给出 “对应功能”。

输出形式

每个测试用例的输出占一行，输出魔咒对应的功能，或者功能对应的魔咒。如果魔咒不在词典中，就输出 “what?”

【样例输入】

[expelliarmus] the disarming charm
[rictusempra] send a jet of silver light to hit the enemy
[tarantallegra] control the movement of one's legs
[serpensortia] shoot a snake out of the end of one's wand
[lumos] light the wand
[obliviate] the memory charm
[expecto patronum] send a Patronus to the dementors
[accio] the summoning charm
@END@
4
[lumos]
the summoning charm
[arha]
take me to the sky

样例输出

light the wand
accio
what?
what?

解题思路

咒语和效果都不一定只有一个词，所以需要使用getline一次读一行，然后再根据 ] 的位置分割（substr大法好）。别的应该没什么难的。

4. 打牌

个人难度评级：2

问题描述

牌只有1到9，手里拿着已经排好序的牌a，对方出牌b，用程序判断手中牌是否能够压过对方出牌。
规则：出牌牌型有5种
[1] 一张如4则5…9可压过
[2] 两张如44则55，66，77，…，99可压过
[3] 三张如444规则如 [2]
[4] 四张如4444规则如 [2]
[5] 五张牌型只有12345 23456 34567 45678 56789五个，后面的比前面的均大。

输入形式

输入有多行，第一行代表手中的牌，长度不超过200个数字。接下来的每一行代表每次对方出的牌。

输出形式

输出有多行，代表手中的牌是否能压过对方出的牌，压过输出YES，并列出所有可选项，可选项之间用空格分隔。否则输出NO。

样例输入

17624234556367
33
222
34567

样例输出

YES 44 55 66 77
YES 666
NO

解题思路

题意似乎没说牌放不放回…… 不过没说过出牌规则，应该是出牌后放回手牌的。

直接模拟即可，分几张牌的情况。五张牌情况不多，而且取起来也麻烦，建议直接对每种情况做特判。

（WA了一半多，不确定做法是否正确）

5. 最大报销额

来源：HDU 1864（无法访问可移步 Vjudge）

个人难度评级：3

问题描述

现有一笔经费可以报销一定额度的发票。允许报销的发票类型包括买图书（A类）、文具（B类）、差旅（C类），要求每张发票的总额不得超过1000元，每张发票上，单项物品的价值不得超过600元。现请你编写程序，在给出的一堆发票中找出可以报销的、不超过给定额度的最大报销额。

输入形式

测试输入包含若干测试用例。每个测试用例的第1行包含两个正数Q和N，其中Q是给定的报销额度，N（N<=30）是发票张数。随后是N行输入，每行的格式为：
m Type_1:price_1 Type_2:price_2 … Type_m:price_m
其中正整数m是这张发票上所开物品的件数，Type_i和price_i是第i项物品的种类和价值。物品种类用一个大写英文字母表示。当N为0时，全部输入结束，相应的结果不要输出。

输出形式

对每个测试用例输出1行，即可以报销的最大数额，精确到小数点后2位。

样例输入

200.00 32 A:23.50 B:100.001 C:650.003 A:59.99 A:120.00 X:10.001200.00 22 B:600.00 A:400.001 C:200.501200.50 32 B:600.00 A:400.001 C:200.501 A:100.00100.00 0

样例输出

123.501000.001200.50

解题思路

第一个困难其实是阅读理解。很容易能看出来这题是一个01背包问题，但背包里装的是什么呢？其实是发票。将发票各物品的 ** 总价值 ** 作为 ** 整一件 ** 物品的价值，而对于每组数据，有多张发票，那就是求如何取 ** 整张 ** 发票，能够让报销额尽可能接近报销上限而不超过。所以，只需要存储每张发票的总金额就可以了。

第二个困难是允许报销类型限制、每件物品金额限制和发票总金额限制。因为报销只能整张一起报，所以出现任何一个上述的例外情况，** 整张发票作废 **（可将金额存储为0）。

第三个困难是如何写DP。相信很多人已经背熟01背包了，但对于没背熟的人来说，这也许不算什么困难，毕竟当看到N<=30的时候，我相信你和我是一样的反应：直接暴力搜，管那么多干什么？确实，数据范围太菜，直接搜确实没问题。

第四个困难是初始化变量。老生常谈了，有多组数据的题要记得初始化。

6. 带通配符的数

个人难度评级：2

问题描述

给定一个可以带通配符问号的正整数W，问号可以代表任意一个一位数字。再给定一个正整数X，和W具有同样的长度。问有多少个整数符合W的形式并且比X大？

输入形式

多组数据，每组数据两行，第一行是W，第二行是X，它们长度相同，在 [1..10] 之间。

输出形式

每行一个整数表示结果。

样例输入

36?1?82364288?3910?5

样例输出

解题思路

通配符的数量不确定，那就dfs啊。

7. 愚人节的礼物

个人难度评级：1

问题描述

四月一日快到了，Vayko想了个愚人的好办法——送礼物。嘿嘿，不要想的太好，这礼物可没那么简单，Vayko为了愚人，准备了一堆盒子，其中只有一个盒子里面装了礼物。盒子里面可以再放零个或者多个盒子。假设放礼物的盒子里不再放其他盒子。用 () 表示一个盒子，B表示礼物，Vayko想让你帮她算出愚人指数，即最少需要拆多少个盒子才能拿到礼物。

输入形式

本题目包含多组测试，请处理到文件结束。每组测试包含一个长度不大于1000, 只包含 ‘(’,’)’ 和’B’ 三种字符的字符串，代表Vayko设计的礼物透视图。你可以假设，每个透视图画的都是合法的。

输出形式

对于每组测试，请在一行里面输出愚人指数。

样例输入

((((B)()))())
(B)

样例输出

4
1

解题思路

可别把它当括号匹配做啊，题目给出的括号串是完全合法的，不需要检验合法性，甚至用不到STL stack，只需要一个整型模拟栈的元素数量，统计左括号数量就行了。

8. ab串

个人难度评级：3

问题描述

给定一个由字符’a’ 和字符’b’ 组成的字符串，可以删除若干字符，使得剩下来的字符串满足前后段为a，中间段为b（aaa….aaabbbb…..bbbbaaa…..aaa）, 区段可以没有字符（ba,ab,b,aa都是合法的），求最长剩下字符串的长度。

输入形式

输入为一行一个长度不超过5000的非空字符串，字符串仅由字符’a’ 和字符’b’ 组成。

输出形式

输出为一个整数，表示符合要求的最长剩下字符串长度

样例输入1

abba

样例输出1

样例输入2

bab

样例输出2

解题思路

前缀和？什么是前缀和？影响我打暴搜吗？题目数据似乎很菜，分块不多，要不然真搜不完。

将原字符串分割为内部完全由a/b组成的小块，用 pair<int,string> 存储，比如aabaa可以分割成长度为2的a块、长度为1的b块、长度为2的a块。这里可以使用string的find函数减少工作量。遇到b开头的串其实也不用慌，完全可以先统计a块，最终会在最前面形成一个长度为0的a块，并不影响做题。

然后开始逐块进行深搜。将其化为三种阶段，前面的a串、中间的b串和后面的a串。具体的我再想想怎么讲，建议先去看看代码。大致上就是根据当前搜到a串还是b串来分，然后在此基础上再分1、2或3阶段分情况讨论。

9. 占座位

个人难度评级：4

问题描述

sun所在学校的教室座位每天都是可以预占的。
一个人可以去占多个座位，而且一定是要连续的座位，如果占不到他所要求的这么多座位，那么他就一个座位也不要了。为了降低难度，每次分配座位按座位号从小到大查找，采用最先适配法分配座位。

输入形式

输入有多组数据。
每组数据输入座位排数n，0<n<=100（座位的排列数相等，座位是按每行从左到右依次排序的, 第1行的最右边一个座位与第二行的第一个座位视为连续座位），m（0<m<=min(100,n*n) ）个人。
然后输入k（0<k<=100），最后输入k个命令。
命令只有两种：
1.in id num（代表id,0<=id<m, 要占num个座位，若占不到连续的num(0<num<=20) 个座位表示该命令无效）
2.out id（代表id要释放他之前占的所有座位）
注意：如果id之前占过座还没释放那么之后他的in命令都是无效的，
如果id之前没占过座位那么他的out命令也是无效的。

输出形式

对每个in命令输出yes或者no，如果命令有效则输出yes，无效则输出no。
在yes no后面只带有回车，不带其他任何字符。

样例输入

4 10
9
in 1 7
in 2 3
in 3 3
in 3 3
in 4 3
out 2
in 5 6
out 3
in 5 6

样例输出

yes
yes
yes
no
yes
yes
no
yes
yes

解题思路

这题几乎完全是内存管理一题的翻版…… 甚至还要简单些，因为阅读理解的困难变小了很多，并且没有碎片整理部分。

座位好几排？没有关系，前一行最后一个和下一行第一个视为连续座位，那不就和内存空间差不多了嘛……

顺便吐槽一下CG的样例，格式也太不标准了点。

10. Maya历法

个人难度评级：2

问题描述

在学术休假期间，M.A. Ya教授在古老的Maya历法上有一个惊人的发现。从一个古老的令人棘手的信息中，教授发现Maya文明以365天为一年，称为Haab，包含19个月。前18个月每月有20天，月份名字为：pop、no、zip、zotz、tzec、xul、yoxkin、mol、chen、yax、zac、ceh、mac、kankin、muan、pax、koyab、cumhu。每月的天数使用数字来表示，从0~19，而不是用名字。Haab的最后一个月叫做uayet，有5天，表示为0、1、2、3、4。玛雅人认为这个月是不吉利的，法院不开庭，贸易停止了，人们甚至停止清扫地板。

出于宗教的目的，Maya人使用另外一套历法，叫做Tzolkin（冬青年）。一年被分为13个期间，每个期间20天。每天被表示为由数字和日期名表示的数对。使用20个名字：imix、ik、akbal、kan、chicchan、cimi、manik、lamat、muluk、ok、chuen、eb、ben、ix、mem、cib、caban、eznab、canac、ahau，以及13个数字，双循环使用。

请注意，每一天都有一个明确的描述。例如，在年初的日子被描述如下：

1 imix, 2 ik, 3 akbal, 4 kan, 5 chicchan, 6 cimi, 7 manik, 8 lamat, 9 muluk, 10 ok, 11 chuen, 12 eb, 13 ben, 1 ix, 2 mem, 3 cib, 4 caban, 5 eznab, 6 canac, 7 ahau, 在下一个期间开始为8 imix, 9 ik, 10 akbal . . .

年份（包含Haab和Tzolkin) 用数字0、1、… 来表示，数字0是世界的开始。因此，第一天表示为：

Haab: 0. pop 0

Tzolkin: 1 imix 0

请帮M.A.Ya教授写一个程序，将Haab日历转换为Tzolkin日历。

输入形式

在Haab中日期用以下形式表示：

NumberOfTheDay. Month Year

输入文件的第一行包含文件中输入日期的数目。接下来的n行包含Haab日历格式的n个日期，年份小于5000。

输出形式

Tzolkin日期用一下格式：

Number NameOfTheDay Year

输出包括n行，按照与输入日期对应的顺序，输出tzolkin日历格式日期。

样例输入

310.zac 00.pop 010.zac 1995

样例输出

3 chuen 01 imix 09 cimi 2801

解题思路

阅读理解题，难度全在对两种历法的阅读理解上。如果觉得题目读不懂，可以阅读一下玛雅历 - 维基百科，自由的百科全书（需要魔法上网）。

还读不懂？不妨这样：

输入的历法叫Haab历，它一年有365天，其中包含19个月，前18个月每月20天，第19个月只有5天。这20个月用名字来表示，分别叫做pop、no、zip、zotz、tzec、xul、yoxkin、mol、chen、yax、zac、ceh、mac、kankin、muan、pax、koyab、cumhu。每个月的日期使用数字表示。

需要输出的历法叫Tzolkin历。它并没有传统意义上的 “月” 和“日”，而是用20个 “日名” 和13个 “日数” 的组合来确定一年中唯一的日期，比较像中国的天干地支纪年法。日名和日数各自独立循环使用。天干地支纪年法60年一个循环，那么Tzolkin历就是260天一个循环，也就是一”年“。日名循环的每一天分别叫做imix、ik、akbal、kan、chicchan、cimi、manik、lamat、muluk、ok、chuen、eb、ben、ix、mem、cib、caban、eznab、canac、ahau，而日数循环则直接用1-13的自然数表示。

顺便，注意 “0日” 和“13日”的转换。

11. 数码管

个人难度评级：1

问题描述

液晶数码管用七笔阿拉数字表示的十个数字，把横和竖的一个短划都称为一笔，即７有３笔，８有７笔等。对于十个数字一种排列，要做到两相邻数字都可以由另一个数字加上几笔或减去几笔组成，但不能又加又减。比如７→３是允许的，７→２不允许。任意输入一组数，判断是否符合上述规则，注意，1在右边。

输入形式

每行输入一个0~9的排列，数字之间用空格分隔，以 - 1作为输入结束

输出形式

输出YES或NO

样例输入

4 1 0 7 3 9 5 6 8 2
3 5 1 6 2 7 9 0 4 8
-1

样例输出

YES
NO

解题思路

打表神题，直接预先在纸上算出数字转换关系的邻接矩阵，用的时候直接读取即可。这个关系是对称的，也就是说a能转换为b则b也能转换为a。特别要注意打表的准确性，如果打错了那就完蛋了…… 建议打2遍。

bool isTransferrable[10][10] = {{1, 1, 0, 0, 0, 0, 0, 1, 1, 0},
                                {1, 1, 0, 1, 1, 0, 0, 1, 1, 1},
                                {0, 0, 1, 0, 0, 0, 0, 0, 1, 0},
                                {0, 1, 0, 1, 0, 0, 0, 1, 1, 1},
                                {0, 1, 0, 0, 1, 0, 0, 0, 1, 1},
                                {0, 0, 0, 0, 0, 1, 1, 0, 1, 1},
                                {0, 0, 0, 0, 0, 1, 1, 0, 1, 0},
                                {1, 1, 0, 1, 0, 0, 0, 1, 1, 1},
                                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                                {0, 1, 0, 1, 1, 1, 0, 1, 1, 1}};

可以使用stringstream承接一行一行的输入，然后逐个读取。

12. 多项式加法

个人难度评级：2

问题描述

一个多项式可以表示为一组数对，数对中第一个数始终为整数，且唯一，表示多项式的次数，另一数表示为对应的系数且不为0。输入两组数对，每组以0 0作为结束，实现对两个多项式的加法并按降幂输出结果数对

输入形式

每行输入一个数对，以空格为分隔符，以0 0结束

输出形式

每行输出一个数对，以空格为分隔符

样例输入

样例输出

解题思路

很容易想到使用数组来存放各个次数的系数，但次数只说了是整数，先不必说太大咋办，首先负系数就能把数组方案毙掉了（虽然还是能得大约60分）。这时候使用std::map就十分有必要了，不过这样的话要考虑相加之后系数为0的情况。

正常考试的时候应该会有数据范围的，只要能看到，就一般能想到不能用数组存。

13. 数字统计

个人难度评级：1

问题描述

给定一个k位整数N = dk-1*10k-1 + … + d1*101 + d0 (0<=di<=9, i=0,…,k-1, dk-1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定N = 100311，则有2个0，3个1，和1个3。

输入形式

每个输入包含1个测试用例，即一个不超过1000位的正整数N。

输出形式

对N中每一种不同的个位数字，以D:M的格式在一行中输出该位数字D及其在N中出现的次数M。要求按D的升序输出

样例输入

样例输出

0:2
1:3
3:1

解题思路

这个有啥好讲的啊……

14. A除以B

个人难度评级：1

问题描述

本题要求计算A/B，其中A是不超过1000位的整数（A>=0），B是1位正整数。你需要输出商数Q和余数R，使得A = B * Q + R成立。

输入形式

输入在1行中依次给出A和B，中间以1空格分隔。

输出形式

在1行中依次输出Q和R，中间以1空格分隔。

样例输入

123456789050987654321 7

样例输出

17636684150141093474 3

解题思路

挺简单一道题，就是高精除低精。但是要注意两点：

去掉前导0；
不要把商为0当成前导0给去掉了（这个会卡测试数据3）。

15. 公交系统

个人难度评级：2

问题描述

城市公交系统有一个记录仪，用于记录每个站点的乘客人数的变化情况，例如：x表示到站前公交车上的乘客人数，y表示离站时公交车上的乘客人数，则该记录仪记录的该站的数字为y-x。

对于一辆公交车和n个车站，a1,a2,…,an为该公交车在各站的记录数据。

假定w为该公交车可容纳的最大乘客人数，编程求出在第一站停靠之前公交车上人数的可能数据有多少种？

输入形式

第一行包含两个数据n和w(1<=n<=1000, 1<=w<=109)，分别表示车站的数目和公交车可容纳的最大乘客人数。

第二行包含一个序列a1,a2,…,an，表示记录仪记录的各站的数据。

输出形式

输出一个整数，表示公交车在第一站停靠之前可能的乘客人数数据的个数，如果没有，则输出0。

样例输入1

3 5
2 1 -3

样例输出1

样例输入2

2 4
-1 1

样例输出2

样例输入3

4 10
2 4 1 2

样例输出3

样例说明

在第一个样例中，乘客数可能有0、1、2，共3种情况

在第二个样例中，乘客数可能有1、2、3、4，共4种情况

在第三个样例中，乘客数可能为0或1，共2种情况

解题思路

假定一开始车上有0个人，然后录入变动情况，记录车上的最大最小人数。

如果最大人数超过额定载客量，或者最大人数和最小人数的差大于额定载客量，则输出0。

在最小人数大于等于0的情况下，只需要满足最大人数 + 初始人数 <= 额定载客量即可；如果小于 0，则还需要满足最小人数 + 初始人数>=0。

满足以上条件的初始人数情况数，即为结果。

16. 成绩大派对

个人难度评级：1

问题描述

读入n名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

输入形式

每个测试输入包含1个测试用例，格式为

第1行：正整数n 第2行：第1个学生的姓名学号成绩第3行：第2个学生的姓名学号成绩 … … … 第n+1行：第n个学生的姓名学号成绩

其中姓名和学号均为不超过20个字符的字符串，成绩为0到100之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出形式

对每个测试用例输出2行，第1行是成绩最高学生的姓名和学号，第2行是成绩最低学生的姓名和学号，字符串间有1空格。

样例输入

3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95

样例输出

Mike CS991301
Joe Math990112

解题思路

分别维护姓名、学号和成绩的临时变量、最大值、最小值，边输入边更新即可。

17. 字符串数字置换

个人难度评级：1

问题描述

从键盘接收用户输入的字符串, 对用户输入的每个字符串的处理是：将字符串内的每一个十进制数字字符置换成下列表格中右边所对应的一个字符串（所有其他字符不变），然后将转换的结果显示在屏幕上；并分别计算每个数字的置换次数。

十进制数字字符	置换成
0	(Zero)
1	(One)
2	(Two)
3	(Three)
4	(Four)
5	(Five)
6	(Six)
7	(Seven)
8	(Eight)
9	(Nine)

例如，若用户输入的字符串为

Page112-Line3，

则程序5的输出是：

Page(One) (One) (Two)-Line(Three),

数字0到9的置换次数分别是 0 2 1 1 0 0 0 0 0 0

输入形式

输入一行字符串，其中可包含字母、数字、空格或其他符号（英文）

输出形式

第一行为将字符串中的数字转换为表格中的内容后输出

第二行为数字0~9被转换的次数

样例输入

Page112-Line3

样例输出

Page(One)(One)(Two)-Line(Three)
0 2 1 1 0 0 0 0 0 0

解题思路

没什么好讲的

18. 写出来吧

个人难度评级：1

问题描述

读入一个自然数n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入形式

每个测试输入包含1个测试用例，即给出自然数n的值。这里保证n小于10的100次方。

输出形式

在一行内输出n的各位数字之和的每一位，拼音数字间有1空格，但一行中最后一个拼音数字后没有空格。

样例输入

1234567890987654321123456789

样例输出

yi san wu

样例说明

友情提示汉语拼音

0~9：ling yi er san si wu liu qi ba jiu shi

解题思路

没什么好讲的，倒是这拼音提示挺侮辱智商的。

19. 到底买不买

个人难度评级：1

问题描述

小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。

为方便起见，我们用 [0-9]、[a-z]、[A-Z] 范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。

输入形式

每个输入包含1个测试用例。每个测试用例分别在2行中先后给出摊主的珠串和小红想做的珠串，两串都不超过1000个珠子。

输出形式

如果可以买，则在一行中输出 “Yes” 以及有多少多余的珠子；如果不可以买，则在一行中输出 “No” 以及缺了多少珠子。其间以1个空格分隔。

样例输入

ppRYYGrrYBR2258YrR8RrY

样例输出

Yes 8

解题思路

这是一个很好想很好写很好调但未必快的思路。

我们都知道char本质上是用ASCII码存储的，那么统计某个字符串中某字符出现数量，可以直接加到对应ASCII码下标的数组值里面。

遍历一遍待买的字符串和想要的字符串，分别加到两个数组里，然后分别统计少的和多的即可。

注意数组要开大点，ASCII码范围是0-127，我们需要的最大是z即122。

一个更好的方案是使用std::map来维护对应关系。

20. 挖掘机技术哪家强

个人难度评级：1

问题描述

为了用事实说明挖掘机技术到底哪家强，组织一场挖掘机技能大赛。现请你根据比赛结果统计出技术最强的那个学校。

输入形式

输入在第1行给出不超过105的正整数N，即参赛人数。随后N行，每行给出一位参赛者的信息和成绩，包括其所代表的学校的编号、及其比赛成绩（百分制），中间以空格分隔。

输出形式

在一行中给出总得分最高的学校的编号、及其总分，中间以空格分隔。题目保证答案唯一，没有并列。

样例输入

63 652 801 1002 703 403 0

样例输出

2 150

问题说明

建议练习使用STL中的map

解题思路

建议翻别人用map写的题解，我没用。毕竟总共105个学校，又不是不能用数组。

21. Web导航

个人难度评级：1

问题描述

标准的Web浏览器具有在最近访问的页面中前后移动的特性。实现这些特性的一种方法是使用两个堆栈来跟踪可以通过前后移动到达的页面。在这个问题中，我们要求实现这一点。

需要支持以下命令：

BACK：将当前页面压入前向堆栈的顶部；从后向堆栈的顶部弹出该页，使其成为新的当前页。如果后向堆栈为空，则该指令忽略。

FORWARD：将当前页面压入后向堆栈的顶部；从前向堆栈的顶部弹出该页，使其成为新的当前页。如果前向堆栈为空，则该指令忽略。

VISIT：将当前页面压入后向堆栈的顶部，将URL指定为新的当前页。前向堆栈被清空。

QUIT：退出浏览器。

假设浏览器最初在网址http://www.game.org / 上加载网页。

输入形式

输入是一个命令序列。命令关键字BACK、FORWARD、VISIT和QUIT都是大写。URL中无空格，最多有70个字符。假定在任何时候，每个堆栈中没有问题实例需要超过100个元素。输入的结尾由QUIT命令标识。

输出形式

除QUIT外的每个命令，如果命令没有被忽略，则在命令执行后输出当前页面的URL，否则，打印 “Ignored”。每个命令的输出独立打印一行。QUIT命令无输出。

样例输入

VISIT http://game.ashland.edu/VISIT http://game.baylor.edu/acmicpc/BACKBACKBACKFORWARDVISIT http://www.our.com/BACKBACKFORWARDFORWARDFORWARDQUIT

样例输出

http://game.ashland.edu/
http://game.baylor.edu/acmicpc/
http://game.ashland.edu/
http://www.game.org/
Ignored
http://game.ashland.edu/
http://www.our.com/
http://game.ashland.edu/
http://www.game.org/
http://game.ashland.edu/
http://www.our.com/
Ignored

解题思路

直接照着题上的提示写就行了，没有特殊情况。

湖南大学 2021 程序设计训练笔记 - 作业训练 5

Mon, 12 Jul 2021 00:00:00 +0000

所有代码均已上传至我的 GitHub 及我的 Gitea。不保证代码均正确（如不正确会在Commit详情标出），正确的也不保证为最优解。

1. Dijkstra?

来源：CF20C 数据已弱化

个人难度评级：3

问题描述

给定一个含权的无向图，顶点编号为 $1-n$，你的任务为找出顶点 $1$ 到顶点 $n$ 之间的最短路径。

输入形式

输入的第一行为两个整数 $n$ 和 $m(2 \le n \le 10^5,0 \le m \le 10^5)$，其中 $n$ 为顶点数，$m$ 是边数。

接下来的 $m$ 行包含用形式 $a_i$、$b_i$ 和 $w_i(1 \le a_i, b_i \le n,1 \le w_i \le 10^6)$，这 $a_i$、$b_i$ 是边的端点，而 $w_i$ 是边的长度。

该图可能包括环，或者一对顶点之间包含多条边。

输出形式

如果无路径，输出 $-1$，否则输出最短路径，如果有多个，则输出字典序最小的路径。

对于两个整数序列 $A(a_1、a_2、…)$ 和 $B(b_1、b_2、…)$，称序列 $A$ 字典序小于序列 $B$ 当且仅当，存在 $k \ge 1$，$i \le k$ 时，$a_i \le b_i$，$i=k$ 时，$a_i < b_i$ 。

样例输入

样例输出

1 4 3 5

解题思路

首先提前说一下，别看它 $10^7$ 的数据范围，其实并没有几条边，可以说是弱中弱了。如果想通过原题，可以试着看看洛谷等地的题解。

所以说这是个模板题，就像 Luogu P3371 一样？不是，起码不完全是。

它加入了路径输出，而且还要输出字典序最小的路径。我的解决方法是为每个点增加一个vector，存储从1号点到这里最短且字典序最小的路径，当检测到更短的路径时一律替换为更短的路径并更新dist数组，而当检测到同样长度的路径时，如果字典序更小，就替换路径。

如何比较vector的字典序？那当然是手撸比较函数。那string自带比较函数，为什么不用string存路径？因为它会认为 1 3 15 2 要比 1 3 5 2 字典序更小。

2. 0-1串

来源：Codeforces 327A Flipping Game

个人难度评级：2

问题描述

对于一个包含 $n$ 个整数元素的序列 $a_1$、$a_2$、…、$a_n$，每个元素的值或者是 $0$ 或者是 $1$，选择两个下标 $i$ 和 $j(1 \le i \le j \le n)$, 对于所有的此范围内的元素 $a_k(i \le k \le j)$，执行操作 $a_k=1-a_k$。

选择合适的 $i$ 和 $j$，执行上述操作一次之后，可以得到的新序列中包含 $1$ 的个数最多是多少？

输入形式

输入的第一行为一个整数 $n(1 \le n \le 100)$，接来的一行为 $n$ 个整数，每个整数或者是 $0$ 或者是 $1$。

输出形式

输出为一个整数，表示执行一次上述操作后可以获得的最大 $1$ 的个数。

样例输入1

5
1 0 0 1 0

样例输出1

样例输入2

4
1 0 0 1

样例输出2

样例说明

在第一个样例中，选择 $i=2, j=5$, 改变后的序列为 $[1 1 1 0 1]$，包含4个1，很显然无法改变为 $[1 1 1 1 1]$。

在第二个样例中，选择 $i=2, j=3$，改变后的序列为 $[1 1 1 1]$，包含4个1。

解题思路

CG上的题目标签中赫然写着”动态规划 “” 前缀和 “，但这毕竟是一道CF A题，出现了范围十分小的数据范围，O(n3) 的暴力枚举算法也能轻松通过，即使是CF原数据。枚举左端点和右端点，分别计算区间左边、中间和右边的和相加张，在各种情况中取最大值即可。注意左右端点可以重合，也可以延伸到尽头。

如果嫌左右加和太慢，似乎也可以写棵线段树？其实前缀和优化之后根本不需要对左右两边进行加和，只需要对翻转的部分进行操作。对此，你可以看洛谷的题解，有一些写得不错。

3. 良心树

来源：Codeforces 1143C

个人难度评级：4

问题描述

给定一颗有根树，顶点编号为 $1~n$，树是一个无环的连通图，有根树有一个特定的顶点，称为根。

顶点 $i$ 的祖先是从根到顶点i的路径上除顶点 $i$ 以外的所有顶点，顶点 $i$ 的父母是 $i$ 的祖先中最接近 $i$ 的顶点，每个顶点都是它父母的孩子。在给定的树中，顶点 $i$ 的父母是顶点 $p_i$，对于根，$p_i$ 为 $-1$。例如：

这是一个 $n=8$ 个顶点的树，根为 $5$，顶点 $2$ 的父母为 $3$，顶点1的父母为 $5$,$6$ 的祖先为 $4$ 和 $5$，$7$ 的祖先为 $8$、$3$ 和 $5$。

在树中，其中一些顶点不尊重其他一些顶点，实际上，如果 $c_i=1$，表示顶点 $i$ 不尊重它的所有祖先，而如果 $c_i=0$，则表示它尊重它所有的祖先。

你需要一个一个地删除一些顶点，在每一步中，选择一个非根顶点，它不尊重它的父母并且它的所有孩子顶点也不尊重它。如果有几个这样的顶点，你需要选择具有最小编号的顶点。当你删除了这样的一个顶点 $v$, 则 $v$ 的所有子顶点与 $v$ 的父母顶点相连。

上图是删除顶点 $7$ 的示例。

直到树中无满足删除标准的顶点，则上述过程停止。按顺序输出你删除的所有顶点，注意这个顺序的唯一的。

输入形式

输入的第一行为一个整数 $n(1 \le n \le 10^5)$，表示树的顶点数。

接下来的 $n$ 行描述了整颗树：第 $i$ 行包含两个整数 $p_i$ 和 $c_i(1 \le p_i \le n,0 \le c_i \le 1)$，这里 $p_i$ 是顶点 $i$ 的父母，若 $c_i=0$，表示顶点 $i$ 尊重它的父母，$c_i=1$，表示顶点 $i$ 不尊重它的父母，$p_i=-1$ 时，表示顶点 $i$ 是树的根，同时 $c_i=0$。

输出形式

如果树中至少有一个顶点被删除，则按照顺序输出顶点编号，否则输入 $-1$。

样例输入1

样例输出1

1 2 4

样例输入2

样例输出2

-1

样例输入3

样例输出3

样例说明

第一个样例的删除过程如下（在图中，$c_i=1$ 的顶点是黄色的）

首先删除顶点 $1$，因为它不尊重祖先并且它的所有孩子也不尊重它，而 $1$ 是这样的顶点中编号最小的
删除后顶点 $2$ 将连接到顶点 $3$
然后删除顶点 $2$，因为它不尊重祖先并且它的所有孩子也不尊重它。
顶点 $4$ 将连接到顶点 $3$
然后删除顶点 $4$，因为它不尊重祖先，并且它的所有孩子也不尊重它（无孩子）
无更多顶点可删

在第二个样例中，无需删除顶点

顶点 $2$ 和 $3$ 的孩子尊重它们
顶点 $4$ 和 $5$ 尊重它们的祖先

在第三个样例中显示如下

解题思路

CG系统上的翻译帮了倒忙，Codeforces的题目原文也不难懂，建议去看英文原文，能够对题面有更好的理解。

下面介绍的是一种思考有难度，而其他方面十分有优势的做法。不需要图论知识，不需要树论知识（需要的知识原题已讲明），更不需要DFS！推荐大家去看Luogu@songhongyi的题解，讲得非常清楚，切中要害：题解 CF1143C 【Queen】 - 一位编程爱好者 - 洛谷博客 (luogu.org)

这道题的一个条件十分重要：不尊重就是不尊重所有祖先，同样尊重的话也是尊重所有祖先。如果一个顶点被移除，那么它的所有子结点都不尊重它，它自己也不尊重父结点。这一支，以前是，把子结点连到父结点之后也是，都是不尊重父结点的。至于尊重的，根本就不会被移除，当然更没有影响。也就是说，移除顶点时，临近点的受尊重状态并不会随之改变。

这样，从小到大删除并输出符合条件的结点，就可以转化为仅从小到大输出符合条件的结点，而不用真正的删除，反正删不删造成的影响实际上并不重要；洛谷的题目翻译隐去了这部分推导过程，使得题目变得过于简单，所以我认为不甚合适。

基于以上原因，我们进一步的确定，根本不需要建树。将每个结点输入并将那两个条件计算即可。上述的那篇题解提供了非常好的办法：位运算，准确的说是位与。初始将每个结点都设为被所有子节点不尊重，然后对它每个子节点，如果有一个尊重它，按位与之后，就是0，即被尊重。

4. 最昂贵的旅行

个人难度评级：2

问题描述

这个国家有 $n$ 个城市，编号从 $0~n-1$，城市网络中没有任何环路，但可以从任意一个城市出发沿公路直接或间接到达其他城市。

有人住在编号为 $0$ 的城市里，他希望去其他的一个城市旅行，但他不想付出更多的成本，所以他想知道去哪个城市的成本是最高的。

输入形式

输入的第一行为一个整数 $n(3 \le n \le 100)$，接下来的 $n-1$ 行每行包括 $3$ 个整数 $u、v、c(0 \le u,v \le n-1,1 \le c \le 10^4)$，意为在城市 $u$ 和 $v$ 之间有公路直接相连，且旅行需要花费的成本为 $c$。

输出形式

输出为一个整数，表示从城市 $0$ 出发去到其他的某个城市，需要付出的最大成本。

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

解题思路

题意：求单源最短路径中的最大值。

其实基本就是dijkstra模板题，如果你会了第1题，没有理由不会这道题。

一个小坑：道路是双向的，这体现在样例2中，如果是单向道路，那么城市1就不能到达，而题中保证了所有城市都可以到达。

5. 猫与餐厅的故事

来源：Codeforces 580C（数据差别很大）

个人难度评级：4

问题描述

公司今天发薪，阿迪想与朋友们去餐厅庆祝一下。

他住在一个非常神奇的公园里，这个公园是一个根在顶点 $1$，且由 $n$ 个顶点组成的有根树，顶点1也就是他的住所。然而不幸的是，公园也有许多的猫，阿迪已经找出了所有包含猫的顶点。

公园的叶子顶点都有餐厅，阿迪想选择一家他可以去的餐厅，但很不幸，他非常害怕猫，因而如果从餐厅去往他家的路径上有连续包含猫的数量超过 $m$ 时，他将不能去往这家餐厅。

你的任务是帮助他确认他能去的餐厅的数量。

输入形式

输入的第一行包含两个整数 $n$ 和 $m(2 \le n \le 10^5, 1 \le m \le n)$，分别表示树的顶点数以及对于阿迪来说可以忍受的最大的包含猫的连续顶点数。

第二行包含 $n$ 个整数 $a_1$、$a_2$、…、$a_n$，这里的每个 $a_i$ 或者为 $0$（顶点 $i$ 无猫），或者为 $1$（顶点 $i$ 有猫）。

接下来的 $n-1$ 行包含用形式 “$x_i$ $y_i$”（$1 \le x_i,y_i \le n, x_i \neq y_i$）表示的树的边，表示顶点 $x_i$ 和顶点 $y_i$ 之间有边相连。

输出形式

输出为一个整数，表示从阿迪家去往叶子顶点的路径上至多包含 $m$ 只猫的叶子顶点的数量。

样例输入1

样例输出1

样例输入2

7 1
1 0 1 1 0 0 0
1 2
1 3
2 4
2 5
3 6
3 7

样例输出2

样例说明

很显然，树是具有 $n$ 个顶点 $n-1$ 条边的连通图，有根树是有一个称为根的特殊顶点的树。

在样例一中

包含猫的顶点变为红色，餐厅在顶点2、3、4，阿迪不能去到在顶点2的餐厅。

在样例二中

餐厅在顶点4、5、6、7，阿迪不能去到6和7。

解题思路

这题我CF全过了，但CG全部WA，扫了一眼，似乎CG的样例比CF还猛（以至于无法显示整个样例）…… 翻译质量倒是还凑合，起码比英语读着舒服了。

此题的数据结构是树，但不是二叉树，所以并不建议使用二叉树的表示方式记录，而应该使用图的方式（毕竟树也是图嘛）。你可以使用邻接矩阵或者邻接表存储，但我更推荐链式前向星，下面的思路也是基于链式前向星展开的。

需要注意结点的编号从1开始。考虑到链式前向星，我建议边的下标也从1开始。为了防止输入边的方向并不是从根节点向叶子结点，可以考虑存成无向图，两种方向都存进去，不会MLE。

在构建完成整张图之后，使用DFS从结点1开始搜索，除了要维护当前结点编号之外，还要维护当前路径已经连续有猫的数量。一旦后者大于m，直接return。

除此之外，我们都知道到了叶子结点就要计数。但是如何判断叶子结点呢？我们用 $head[currPos]$ 表示当前结点第一条边的终点下标，而 $next[i]==1$ 第i条边不再有下一条同起点边。叶子结点只连着一条边，所以需要 $next[head[currPos]]==1$ ，来表示currPos只连了一条边（即父节点）。同时为了防止无父节点的根节点被误判，还需要加入 $currPos!=1$ 。

访问过的结点打上visited标记，因存的是无向图，这样可以防止重复访问。visited的结点也可以直接return。

之后就是对当前结点连接的结点的遍历了，如果有猫则当前连续猫数 + 1，否则清空。

6. 旅行的期望值

来源：Codeforces 839C

个人难度评级：4

问题描述

在古代阿拉伯王国，有 $n$ 座城市有 $n-1$ 条道路，每条道路连接两座城市，人们可以从任意城市出发到达另外一座城市。

西蒙住在第一个城市，骑着马沿着马路去旅行，但是这个国家非常多雾，他也看不清楚马把他带向了哪里，当他们到达一个城市时（包括第一个城市），接下来可以去往与该城市相连的任意一个城市，然而他的马有些奇特，就是只会去往以前从未到达过的城市，且对于下一个城市的选择是等概率的，直到没有可以去往的城市为止。

设每条道路的长度为1，从第一个城市开始旅行，那么这次旅行的期望长度（旅行距离的期望值）的多少？

如果你对期望值（平局值）的定义不太了解，可以查阅相关资料。

输入形式

输入的第一行为一个整数 $n(1 \le n \le 100000)$，表示城市的数量。

接下来的 $n-1$ 行，每行包含两个整数 $u_i$ 和 $v_i(1 \le u_i,v_i \le n,u_i \neq v_i)$，表示由第 $i$ 条道路连接的城市。

输入保证能从一个城市到达其他任意一个城市。

输出形式

输出一个数，表示此次旅行的距离的期望值，旅行从城市1开始。

答案的绝对或相对误差不能超过 $10^{-6}$，也就是说，如果你的答案为 $a$，正确答案为 $b$，则如果 $\frac{|a-b|}{max(1,b)} \le 10^{-6}$ 则检查程序会认为你的答案是正确的。

样例输入1

样例输出1

1.500000000000000

样例输入2

样例输出2

2.000000000000000

样例说明

在第一个样例中，旅行可以在等概率在城市3或4结束，城市3的距离为1而城市4的距离为2，因此，期望长度为1.5.

在第二个样例中，旅行可以在城市4或5结束，两个距离都是2，因此期望长度为2。

解题思路

又是奇奇怪怪但不影响做题的翻译。原题还贴了 “期望” 的Wikipedia 链接（英文），CG由于众所周知的原因已经去掉了。

这张图仍然是一棵树，和上题的遍历方法差不太多。每个结点遍历时都要传入一个double类型概率值，代表遍历到此点的概率。因为向子节点走是等概率的，所以子节点的概率要除子节点数量，而这个数量需要提前算。

计算期望，可以选择逐点加上遍历到此点的概率，也可以额外传一个深度的变量，遍历到叶子结点时乘上到此结点的概率一起加到期望里。

题目要求相对误差不超过 $10^{-6}$ 即可，Codeforces确实是这么判的，它的测试数据和样例一样，留了15位小数；而CG似乎严格按照7位小数比对判断，所以直接输出7位小数就可以了。

7. 有效的BFS

来源：Codeforces 1037D

个人难度评级：5

问题描述

在图的BFS（广度优先搜索）中，通常采用队列来保存当前顶点的邻接点，但对对应邻接点的存入顺序没有要求，因此对于一个图的BFS结果可以有多个，在本问题中，从顶点1开始，请验证一个给定的顶点序列是否为一个有效的BFS序列？

输入形式

输入的第一行为一个整数 $n (1 \le n \le 2 \times 10^{5})$ ，表示树中节点的数量。

接下来 $n-1$ 行描述了树的边，每行包含两个整数 $x$ 和 $y(1 \le x,y \le n)$，表示对应边的两个端点，输入保证给定的图构成一颗树。

最后一行为 $n$ 个互不相同的整数 $a_{1}$、$a_2$、……、$a_n (1 \le a_i \le n)$ ，代表待检验的顶点序列。

输出形式

如果待检验的序列是一个正确的BFS序列，输出 “Yes”，否则输出 “No”。

样例输入1

样例输出1

Yes

样例输入2

样例输出2

No

解题思路

个人认为这个图用邻接链表方便点，那就不用前向星了。

BFS中，属于同一个父节点的子节点，访问的顺序是任意的，但惟需保证先访问谁就要先访问谁的儿子。整体的思路就是模拟题中的BFS过程，如果发现按照题中的序列并不能完成BFS，那么就输出no然后 return。

维护一个访问序列的队列 $visitSeq$，就是正常DFS模拟过程中的访问序列；以及一个待检查队列 $reqSeq$，来自题目要求的BFS队列。

可以想到，对于遍历到的每一个BFS结点，它的 $childNum$ 个子节点必须全部放置于 $reqSeq$ 的队首，而队首的 $n$ 个元素也必须全部是这些子节点，否则就不是一个合法的BFS序列（根据先访问谁就先访问谁的子节点）。具体一点，就是逐个检查队首的前 $childNum$ 个元素是否包含在当前元素子节点的集合中，如果包含，则此处的遍历顺序是合法的，将这个元素推入待访问队列；否则，它就不合法。

更具体地来讲，给访问过的结点打上一个 $visited$ 标记，以分辨父节点和子节点。遍历每个结点的时候，将所有 $visited==0$ 的结点扔进一个子节点的 set，它的大小就是 $childNum$。然后检查 $reqSeq$ 的前n个结点是否在set内，如果在，则将其推入 $visitSeq$，同时 reqSeq.pop()；否则，直接输出no然后 return。

对于子节点非常多的测试数据（如Codeforces原题数据48），装进set是一个非常明智的提速方法，$O(log n)$ 查找起来嗖嗖的快。同时也要注意树的遍历第一个结点必须是1，忽视这一点会卡在原题数据39。

8. 数组跳远

来源：Codeforces 1472C

个人难度评级：5

问题描述

对于一个具有 $n$ 个元素的数组 $a$, 执行以下操作：

首先，选择下标 $i(1 \le i \le n)$—— 设置为数组的开始位置，放一个标记在 $i$ 处（在值 $a_i$ 的地方）
当 $i \le n$ 时，你的得分将增加 $a_i$，且将标记向右移动 $a_i$ 个位置，也就是说用 $i+a_i$ 替换 $i$，继续这个过程
如果 $i>n$，则结束操作

例如，如果 $n=5$ 且 $a=[7, 3, 1, 2, 3]$，则可以进行以下操作

选择 $i=1$，操作过程为 $ i = 1 \overset{+7}{\longrightarrow} 8 $，最后得分为 $ a_1 = 7 $
选择 $ i = 2 $，操作过程为 $ i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8 $, 最后得分为 $ a_2 + a_5 = 6 $
选择 $ i = 3 $，操作过程为 $ i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6 $, 最后得分为 $ a_3 + a_4 = 3 $
选择 $ i = 4 $，操作过程为 $ i = 4 \overset{+2}{\longrightarrow} 6 $, 最后得分为 $ a_4 = 2 $
选择 $ i = 5 $，操作过程为 $ i = 5 \overset{+3}{\longrightarrow} 8 $, 最后得分为 $ a_5 = 3 $

请选择合适的开始位置，使得经过上述操作后可获得最大的分数。

输入形式

输入的第一行为一个整数 $ t $ ($ 1 \leq t \leq 10^4 $)，表示测试用例的组数。

每个测试用例的第一行为一个整数 $ n $ ($ 1 \leq n \leq 2 \cdot 10^5 $)，表示数组 $a$ 的元素个数

接下来一行包含 $n$ 个整数 $ a_1, a_2, \dots, a_n $ ($ 1 \leq a_i \leq 10^9 $)，表示数组 $a$ 的元素

输出形式

对于每个测试用例，输出独立一行，表示选择合适的开始位置后经过上述操作可以获得的最大分数。

样例输入

4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1

样例输出

解题思路

借鉴自洛谷 @Melon_Musk 的题解。讲得清楚明白，我觉得我没必要再写了。

因为 $a[i]$ 是按照位置顺序输入的，$a[i]$ 数组没必要全存起来，随输入随处理即可，可以极大幅度节省内存消耗；此人写了一个快读，输入大量数据时能够节省时间消耗，但本题时间限制为2s，scanf实测能过，甚至cin应该也可以。

9. 踩点上课

来源：Codeforces 1520G

个人难度评级：5

问题描述

阿迪通常开着闹钟睡觉，这样他才不至于上课迟到。

他想知道能否赶上第一节课，为了不迟到，他需要知道从家到学校所需要的最少时间是多少。

阿迪生活的城市是一个 $n\times{m}$ 的矩形区域，其中每个单元 $ (i, j) $ 由一个数字 $ a_{ij} $ 来表示

数字为 $-1$ 时表示该单元被占用，禁止通行
数字为 $0$ 时表示该单元是空闲的，阿迪可以穿过
数字为 $ x $ ($ 1 \le x \le 10^9 $) 时表示该单元包含入口，需要耗费的时间成本为 $x$，包含入口的单元也是空闲的，可以自由通行

从任何包含入口的单元出发，阿迪可以去往任何包含入口的其他单元，从入口 $(i,j)$ 到入口 $(x,y)$ 的时间成本总和为 $ a_{ij} + a_{xy} $。

除了在两个包含入口的单元之间移动，他也可以在具有相邻边的未被占用的单元之间移动，耗费的时间为 $w$。实际上，他也可以进入一个包含入口的单元而不使用它。

开始时，阿迪处在左上角单元 $(1, 1)$，而学校位于右下角 $(n,m)$。

输入形式

输入的第一行包含三个整数 $n$、$m$ 和 $ w $ ($ 2 \le n, m \le 2 \cdot 10^3 $ , $ 1 \le w \le 10^9 $)，此处 $n$ 和 $m$ 是城市的大小，$w$ 是在未被占用的单元之间移动所需要的时间。

接下来的 $n$ 行每行包含 $m$ 个数 ($ -1 \le a_{ij} \le 10^9 $ )，表示对单元的描述。

输入保证单元 $(1, 1)$ 和 $(n,m)$ 是空闲的。

输出形式

输出为一个数，表示阿迪去往学校需要花费的最少时间，如果他不能去到学校，则输出 $-1$。

样例输入

5 5 1
0 -1 0 1 -1
0 20 0 0 -1
-1 -1 -1 -1 -1
3 0 0 0 0
-1 0 0 0 0

样例输出

样例说明

第一组样例的说明如下：

解题思路

英语基础还可以的同学可以去看：Codeforces Round #719 (Div. 3) Editorial - Codeforces。

简单来说，首先如果用传送门，必只能用一次以达到花费最小，这样只需要考虑用传送门和不用两种情况。不用传送门，就是找起点到终点的最短路径；而如果用传送门，则需要分别找到与起点和终点间成本最小的点（不只有 $w \times {dist(D,i)}_{min}$，还要加上该传送门的权值 $a_i$，才能代表使用该传送门的成本），然后相加。将两者比较，即可得到最小成本。

具体一点来说，就是分别从起点和终点开始两次BFS，若到达另一端则更新起点终点距离，若遇到传送门则算出成本并更新最小成本值。

注意使用long long存储与距离有关的变量；各种初始值也要设定大一些，否则无法通过Codeforces测试数据（可能会卡在 #122左右，后面几个全是大数据）。

未曾设想的道路

有一种奇怪的想法：结点数和每个结点的边数不算很多，猜想可以建图，对于每个点，与相邻能通过的点之间有长为 $w$ 的边连接；如果此点是传送门点，则与其他传送门点均有长为 $a_i+a_j$ 的边连接。然后使用Dijkstra等单源最短路算法直接算出起点到终点的距离。

10. 树的优化

来源：Codeforces 682C

个人难度评级：6

问题描述

在一个原始森林里，有人发现了一颗根编号为 $1$ 的神奇树，它的每个顶点以及每条边上都标有一个数字。

然而，他发现这颗树上有些顶点有瑕疵，也称为瑕疵点。一个顶点 $v$ 被称为瑕疵点是指在它的子树中存在点 $u$，使得 $dist(v,u)>a_u$，这里 $a_u$ 是标注在顶点 $u$ 上的数字，而 $dist(v,u)$ 是所有标注在从顶点 $v$ 到顶点 $u$ 的路径上边的数字之和。

如果一个顶点只有一条路径相连，则这个顶点是树的叶子节点。但是树的根节点是叶子节点，当且仅当数树仅有一个单一顶点，即根节点。

这人决定删除一些叶子节点，直到整颗树不存在任何瑕疵点。那么，需要删除的叶子节点的最少数是多少？

输入形式

输入的第一行为一个整数 $n$ $(1 \le n \le 10^5 )$。

接下来一行为 $n$ 个整数 $a_1$、$a_2$、…、$a_n$ $(1 \le a \le 10^9)$，这里 $a_i$ 是标注在顶点 $i$ 上的数字。

接下来的 $n-1$ 描述了树中边的情况，第 $i$ 行有两个整数 $p_i$ 和 $c_i$ $(1 \le p_i \le n, -10^9 \le c_i \le 10^9)$，这意味着在顶点 $i+1$ 和 $p_i$ 之间有边相连，其上标有数字 $c_i$

输出形式

输出一个整数，表示需要删除的最少叶子节点数。

样例输入

9
88 22 83 14 95 91 98 53 11
3 24
7 -8
1 67
1 64
9 65
5 12
6 -80
3 8

样例输出

提示

以下是可能的处理过程

解题思路

这个题我做的时候觉得挺难的，主要是没读懂，而且这个题的弯绕得很多，所以给了6级。参考了【Codeforces 682C】Alyona and the Tree - AWCXV - 博客园 (cnblogs.com)。

我们设结点 $u$ 是在结点 $v$ 子树的叶子结点，如果 $dist(v,u)>a_u$，即它们之间的边权和大于 $u$ 点的点权，那么下面的 $u$ 就会让上面的 $v$ 伤心（原题说法，即瑕疵，这里习惯了不改了）。这时候，就要把下面的 $v$ 叶子移除，来让 $u$ 不因它伤心。

能让 $u$ 结点伤心的，并不一定是叶子结点，而是任何能满足边权和大于 $v$ 点权的 $v$ 结点，即使 $v$ 在中间；而只要让 $u$ 伤心，就必须移除 $v$。题面要求我们只能移除叶子结点，这样的话，如果子树中的中间结点 $v$ 让 $u$ 伤心，必须移除 $v$ 为根节点的整棵子树。这样是完全可行的，因为上面的结点伤不伤心，跟 $v$ 的子节点一点关系都没有，爱怎么移除怎么移除，不把下面的移除干净，导致伤心的 $v$ 的还没办法移除。

也正是由于 $v$ 下面的结点和上面结点是否伤心无关，我们可以知道：设结点对 $<u,v>$ 代表下面的 $v$ 让上面的 $u$ 伤心，如果 $<u,v>$ 相比 $<p,q>$ 更靠树的根部（也就是靠上），我们可以直接删除 $v$ 的子树，如果 $<p,q>$ 的关系因删除而不再存在，也并不需要在意，正好一起切没了。

这个时候，就可以想出一个并不是非常高效的算法（但应该能应付CG，没实现，不保证）：

先使用一次DFS，求出根节点和各结点之间的边权和 $dist(1,u)$，存储，因为 $dist(u,v)=dist(1,v)-dist(1,u)$。然后使用第二轮DFS，将每个遍历到的结点作为 $u$，然后再以它为根节点向下进行一层DFS，枚举它的根节点作为 $v$。检验 $u$ 是否会被 $v$ 搞伤心，如果会，直接删除通向 $v$ 的边，代表删除下面的整棵树，不会的话则继续搜索。最后再一轮DFS得到没被删除的结点数量，计算得到删掉的数量（或者在删除结点时，以被删掉的 $v$ 为起点DFS得到被删除的结点数量），输出。

注意到一个问题：对于任意结点 $v$，不管它造成了从 $1$ 到 $v$ 之间哪个结点不高兴，$v$ 为根的树都要被删除。如果我们记录从 $1$ 到 $v$ 以 $v$ 结尾的 ** 最大 ** 边权和，就不需要判上游的特定_某个_结点是否会被搞伤心（上面算法的思想），只需要一次判断，就可以得出上游_是否会有_结点被 $v$ 搞得不伤心，从而直接决定删不删掉 $v$。

那如何得出最大边权和呢？整个过程可以直接整合进一次DFS中，就是这个算法的核心。给DFS函数传入两个变量，当前结点 $u$ 的编号和最大边权和。如果最大边权和大于该节点的权值直接返回，不再搜索下去也不计数，代表这个点被删除。否则，没被删除的点计数 + 1，然后继续DFS，分两种情况：如果当前最大边权和小于0，则传入的最大边权和就是 $u$ 与子节点间的边权；否则，传入当前最大边权和 + 上述边权。这里使用了贪心的思想，来保证边权和最大，且以当前结点 $u$ 结尾。这一段结合代码来讲，就是这样：

cpp

        if (dist> 0) //dist 是当前最大边权和
        {
            dfs(to[i], dist + weight[i]); // 链式前向星存边，边号 i，to[i] 是边的终点，weight[i] 是这条边的边权
        }
        else
        {
            dfs(to[i], weight[i]);
        }

题中数据的输入方式已经表明了谁是更靠近根的节点，我们只需要存储有向边，不会出现下面的结点连往上面结点的边，也就不再需要打标记证明哪个结点访问过。

湖南大学 2021 程序设计训练笔记 - 作业训练 2

Wed, 07 Jul 2021 00:00:00 +0000

1. 字符串反转2

个人难度评级：2

问题描述

给定一个句子（只包含字母和空格），将句子中的单词位置反转，单词用空格分割, 单词之间只有一个空格，前后没有空格。比如： “hello xiao mi”-> “mi xiao hello”

输入形式

输入数据有多组，每组占一行，包含一个句子 (句子长度小于1000个字符)

输出形式

对于每个测试示例，要求输出句子中单词反转后形成的句子

样例输入

hello xiao miI am a student

样例输出

mi xiao hello
student a am I

解题思路

对于每一行，逐个输入单词压入栈，cin.peek到回车 或者文件末尾（用EOF表示，可以用 ^Z触发）就全部输出，因为输入内容最后没有回车，只判断回车是会WA掉大部分点的。

2. 487-3279

来源：UVa 696 测试数据可能不同

个人难度评级：2

问题描述

每个人都喜欢有令人难忘的电话号码。要想让电话号码变得令人难忘的一种方法是拼出一个令人难忘的单词或短语。例如，你可以拨打滑铁卢大学的电话，拨打令人难忘的电话号码TUT-GLOP。

有时只有一部分号码被用来拼写一个单词，例如，你可以拨打310-gino从Gino’s订购披萨。

要使电话号码令人难忘的另一种方法是以一种令人难忘的方式对数字进行分组。你可以从比萨饼小屋中订购比萨饼，方法是拨打他们的 “3个10”，即号码3-10-10-10。

电话号码的标准格式是七位的十进制数字，第三和第四位之间包含连字符（例如888-1200）。电话的键盘提供字母到数字的映射，如下所示：

A, B, C映射到2

D, E, F映射到3

G, H, I映射到4

J, K, L映射到5

M, N, O映射到6

P, R, S映射到7

T, U, V映射到8

W, X, Y映射到9

Q和Z没有映射。连接符不拨号，必要时可加上或去除。TUT-GLOP的标准格式是888-4567，310-GINO的标准格式是310-4466，3-10-10-10的标准格式是310-1010。

当两个电话号码有相同的标准格式时是等价的（拨同样的号码）。

你的公司正在编制本地企业的电话号码目录，作为质量控制的一部分，你需要检查没有两个（或多个）企业具有相同的电话号码。

输入形式

输入包括一个案例。输入的第一行为一个正整数，指定目录中电话号码的数目 (最多100，000)。其余的各行列出目录中的电话号码，每个号码单独占一行。每个电话号码都是一个由十进制数字、大写字母(不包括Q和z) 和连字符组成的字符串。字符串中的七个字符或是数字或是字母。

输出形式

对于出现超过一次的每个号码，按照标准格式每个输出一行，然后是空格，接着输出出现的次数。只出现1次的电话号码不输出。

样例输入

124873279ITS-EASY888-45673-10-10-10888-GLOPTUT-GLOP967-11-11310-GINOF101010888-1200-4-8-7-3-2-7-9-487-3279

样例输出

310-1010 2487-3279 4888-4567 3

解题思路

将每个电话号码转换成int之后存储，sort一遍，然后加上横线再输出重复出现的电话号码和次数即可。

3. 缺席考试的是谁？

个人难度评级：2

问题描述

程序设计考试结束了，传来个不好的消息：有一个学生没参加考试! 需要尽快知道缺席考试的人是谁，以便尽快做出处理。

糟糕的是，尽管有签到表，但由于人数较多，签到情况比较混乱：有的签到表签在一张白纸上，有的虽然签在名册上，但并不是签在自己姓名旁，更有学生签到了别的签到表上……

现在只能根据这2n-1个姓名（名册上有n个学生姓名，签到有n-1个姓名，签到姓名和名册姓名可能混在一起了），来找到缺席考试的人是谁。唯一一个有利的条件是所有参加考试的人都签了名，且只签一次，签名也都正确无误。

现在任务交给你：编写一个程序，找出缺席考试的是谁。

输入形式

有多组测试数据。

每组测试数据开始一行，是一个正整数n，表示总人数，n=0意味着输入结束并且不需要处理。

以下2n-1行，每行一个字符串，长度不超过20，表示一个人的姓名。姓名有大小写的英文字母、常用汉字组成 (注意每个汉字占2个字节，中英文姓名都不排除有重名情况)。

40% 的测试数据1 ≤ n≤ 10；

30% 的测试数据1 ≤ n≤ 100；

20% 的测试数据1 ≤ n≤ 103；

10% 的测试数据1 ≤ n≤ 104；

提示：大量输入数据，C/C++ 输入推荐使用scanf函数

输出形式

对于每组测试数据，输出一行，只包含一个字符串，表示缺席的人的姓名。

样例输入

2
张三
张三
李四
0

样例输出

李四

解题思路

这个题很蛋疼的两个地方是：

不排除有重名的情况，所以不能简单地用bool存储是否签到2次；
签到姓名和名册姓名混在了一起，所以不能采取” 先存后删” 的策略。

但是有一点不会变：没来的人，他的名字出现次数是奇数（因为缺且仅缺了一次）。所以我建立一个pair<string,int> 数组，first存放姓名，second存放名字出现次数。直接读入2n-1行，统计每个名字出现次数，那么出现了奇数次的名字一定存在缺考情况。

中文应该不需要特殊考虑。但如果你用getline函数读取名字，记得也要用getline吸收cin读取n后的回车！用getchar会WA掉。

4. 电话号码

来源：CodeForces 898C

个人难度评级：3

问题描述

Vasya有几本电话簿，记录了他的朋友们的电话号码，每一个朋友都可以有一或几个电话号码。

Vasya决定整理关于朋友电话号码的信息。给定n个字符串，来自于Vasya的电话簿中的条目。每一条都以朋友的姓名开头，然后跟着当前条目中的电话号码个数，然后是本人的电话号码。有可能几个相同的电话被记录在同一个记录中。

Vasya还认为，如果电话号码a是电话号码b的后缀（也就是说，号码b以a结尾），这两个号码被当作同一个电话号码，那么a被认为是无城市代码，它不应该被考虑。

输出整理后Vasya朋友的电话号码信息。有可能两个不同的人有相同的号码。如果一个人有两个电话号码x和y，x是y的后缀（即y以x结尾），则不输出x。

如果Vasya的电话簿中的某些朋友记录了几次，那么只需要记录一次。

输入形式

输入第一行一个整数n(1<=n<=20)，Vasya的电话簿上的条目数。

以下n行后面是描述中的格式记录。朋友的姓名中不包含空字符，长度不超过10位，由小写英文字母组成。电话号码个数在1~~10之间。每个电话号码的长度范围在1~~10之间，可以包含前导0。

输出形式

输出Vasya的朋友的电话号码的有序信息。首先输出电话簿中的朋友数目m。

接下来的m行，包含以格式 “姓名电话号码个数电话号码1 … 电话号码k" 的条目，号码间以空格分隔。每个记录包含当前朋友的所有电话号码。

每个条目输出按照姓名字母序进行排序，电话号码按照从小到大的顺序排列（注意电话号码比较规则：“1”<“01”、“12”<“012”，依此类推）

样例输入

4ivan 3 123 123 456ivan 2 456 456ivan 8 789 3 23 6 56 9 89 2dasha 2 23 789

样例输出

2dasha 2 23 789ivan 4 2 123 456 789

解题思路

定义一个结构体，内含名字、此人的电话数目和一个电话号码数组（字符串类型）。

注意人名有重复，同样的人名要加到一起去；电话号码有后缀情况，要逐个比对，可以考虑善用substr函数。

然后是两层排序，人名和电话号码的排序。注意电话号码不能简单使用std::string重载运算符，短的电话号码被看作小的。

注意所有（最多20）个人名实际上可以都是一个人，再加上每个人名条目都最多10个号码，要过CodeForces的样例，需要把电话号码的数组开大点，不过CG上的样例非常宽松。

5. 点球大战

个人难度评级：1

问题描述

在足球比赛中，有不少赛事，例如世界杯淘汰赛和欧洲冠军联赛淘汰赛中，当比赛双方经过正规比赛和加时赛之后仍然不分胜负时，需要进行点球大战来决定谁能够获得最终的胜利。点球大战的规则非常简单，两方轮流派出球员罚点球，每方各罚5个。当5轮点球结束以后如果仍然不分胜负，则进入一轮定胜负的阶段。两方各派一名球员罚点球，直到有一方罚进而另一方没有进为止。

在北美职业冰球联赛中，也有点球大战。与足球的规则不同的是，它只先罚3轮点球，随后就进入一轮定胜负的阶段，而其他的规则完全一样。

在本题中，输入将给出每次点球是否罚进，而你的任务则是输出一个 “比分板”。

输入形式

输入包含多组数据。每组数据的第一行包含一个整数N(1<=N<=18)，表示双方总共罚了多少个点球，N=0表示输入结束。随后有N行，每行是一个如下形式的字符串：

XXXX good：表示这个点球罚进

或者XXXX no good：表示这个点球没有罚进

其中XXXX表示球员名字（全部由字母和空格组成，保证不会出现歧义）

每一行保证不超过100个字符。

XXXX和good以及XXXX和no、no和good之间保证有且只有1个空格。

good、no good都是小写。本题是大小写相关的。

数据不保证点球大战一定结束，也不保证在结束以后立即结束这组数据（即：不用判断点球大战是否结束，只用把罚进的点球往比分上加即可）。

输出形式

对每组数据，输出一个比分板。一个点球如果罚进，则在对应的地方标上’O’，如果没有进则标上’X’。先罚球的队伍的信息在上面，后罚的在下面。最右边标上两队的比分。具体格式参考样例输出。注意如果一轮点球只罚了一个，则后面那个点球对应的地方写上’-’。

样例输入

6Riise goodBallack goodGerrard no goodLampard no goodFernando Torres goodMalouda good9Christiano Ronaldo no goodMessi no goodGiggs goodAbidal no goodCarrick goodRonaldinho goodRooney goodHenry no goodTevez good0

样例输出

1 2 3 ScoreO X O 2O X O 21 2 3 4 5 ScoreX O O O O 4X X O X - 1

解题思路

如果你知道了string的find函数，那么这个题非常简单，我觉得不需要说思路。

6. 飞行棋

来源：HDU 2240（很可能无法访问）

个人难度评级：2

问题描述

大家当年一定都下过飞行棋吧。现在Lele和Yueyue要下的棋和这个很相似，只是更简单一点而已。

棋盘由N个格子组成，分别标记为第0格到第N-1格。格子分为两种，一种是普通格子，即表示在该格可以停留。否则是特殊的格子，一旦走到上面，就要根据上面标记的数飞到相应的格子上。如果飞到一个特殊的格子上，则可以继续飞。

除了第0格外，其他格子都只能容纳一个玩家。即一旦A玩家已经在某个格子上，B玩家又走到这里，A玩家则会被踢回第0格，而B玩家留在这个格子上面。

第N-1个格子是终点，一旦一个玩家走到这个格子上，该玩家获胜，游戏结束。

刚刚开始时，两个玩家都站在第0格上，依次扔骰子，根据骰子显示的点数走相应的格子数。比如，玩家在第0格，扔出了5点，则会走到第5个格子上。如果玩家走得超出了棋盘的范围，则要往回走一定的步数。比如，棋盘一共有7(0~6) 个格子, 玩家在第4格上，扔出了6点，最终他会走到第2格上 (4->5->6->5->4->3->2)。

根据观察，骰子扔出来的数也是有规律的。
对于每一盘棋，扔出的第一个点数为F0=(A*C+B)%6+1, 第二个点数为F1=(A*F0+B)%6+1, 第三个点数为F2=(A*F1+B)%6+1 …. 依此类推。

每一盘棋都是由Lele先走，现在就请你当裁判，看谁能获胜。

输入形式

      本题目包含多组测试，请处理到文件结束。
      每组数据占两行。
      第一行有4个整数N,A,B,C(含义见题目描述，6<N<200,0<=A,B,C<=2^31)。
      第二行有N个字符串，分别表示棋盘上第0个到第N-1个格子的内容。两个字符串之间用一个空格分隔开。

如果字符串为 “N”, 则表示这个格子为普通格子。否则字符串为 “GX”(X为0到N-1之间的整数) 的形式，其中X表示玩家走到这个格子时，要马上飞到第X个格子。
数据保证第0个和第N-1个格子一定为 “N”。

输出形式

对于每组数据，在一行内输出结果。
如果Lele能赢这盘棋，则输出 “Lele”, 如果Yueyue赢的话，就输出 “Yueyue”。

样例输入

7 1 0 6N G3 N N N N N7 1 0 6N G4 N N N N N

样例输出

LeleYueyue

样例说明

测试用例保证能有确定结果。

解题思路

模拟就完事了，模拟每一步的走法即可。原题是有是否进行不完的判断的，如果有余力可以思考一下。

7. 棋盘

问题描述

棋盘是指一个行和列编号从1~N的NxN的二进制矩阵，当行号和列号之和为偶数时该矩阵对应位置为黑色的 (1)，否则为白色的 (0)。以下图（没了）示为N=1、2、3时的棋盘。

給出一个NxN的二进制矩阵，请找出位于该矩阵内的最大尺寸的完整棋盘，以及最大尺寸棋盘的数量（棋盘可以交叠）。

输入形式

每个测试用例的第一行是一个正整数N(1<=N<=2000)，表示給定矩阵的行数和列数，接下来的N行描述了这个矩阵：每行有N个字符，既可以是 “1”（代表黑块），也可以是“0”（代表白块）。矩阵至少包含一个“1” 字符。

输出形式

输出最大尺寸棋盘的行列的大小，以及最大棋盘的个数，以空格分隔。

样例输入

50010111010001010101011101

样例输出

3 3

解题思路

棋盘用bool二维数组存储即可，反正只有0和1两种值。

枚举棋盘左上角起始点，不是黑的直接跳过。对于黑，先得出一个边长上限，就是起始点距离右边和下边的距离最小值。然后枚举边长，大可以先从2开始，毕竟起始点本身是黑的就一定是个棋盘。由于每次增加边长，相比上一个边长增加的只有最右边和最下边一条，所以在上个边长能够成立的情况下，只需要检查新增加的两条边是否合理即可；相反，不能成立的话，直接break即可，边长小的都不成立那大的更不行了。

验证颜色是否正确的时候，需要注意 “当行号和列号之和为偶数时 “中求和时，以 ** 验证中的棋盘起始点 ** 作为原点，而真正使用的坐标是以 ** 整个大棋盘的 (0,0)** 作为原点。看不懂的话，建议直接去翻我代码……

8 .Engine

来源：HDU 2532（若无法访问，可以看 Vjudge）

个人难度评级：3

问题描述

谷歌、百度等搜索引擎已经成为了互连网中不可或缺的一部分。在本题中，你的任务也是设计一个搜索论文的搜索引擎，当然，本题的要求比起实际的需求要少了许多。
本题的输入将首先给出一系列的论文，对于每篇论文首先给出标题，然后给出它被引用的次数。然后会有一系列的搜索询问，询问标题中包含特定关键词的论文有哪些。
每一个询问可能包含多个关键词，你需要找出标题包含所有关键词的论文。
“包含” 必须是标题中有一个词正好是给定的关键词，不区分大小写。
对每个询问，都按被引用的次数从多到少输出满足条件的论文的标题。如果有被引用的次数相同的论文，则按照论文在输入中的顺序排列，先给出的论文排在前面。

输入形式

输入包含多组数据。
每组数据首先有一行包含一个整数N(1<=N<=1000)，表示论文的数目，N=0表示输入结束。每组论文的信息第一行是论文的标题，由字母（大小写均可）和空格组成，不超过10个词，每个词不超过20个字符，标题总共不超过250个字符。第二行是一个整数K(0<=K<=108)，表示它被引用的次数。在论文信息结束以后，有一行包含一个整数M(1<=M<=100)，表示询问的数目。接下来有M行，每行是一个询问，由L(1<=L<=10) 个空格分开的词构成，每个词不超过20个字符。

输出形式

对每个询问，按照题目给定的顺序输出满足条件的论文的标题；如果没有满足条件的论文，就不输出。在每组询问的输出之后输出一行 “***”，在每组数据的输出之后输出一行 “—”。

样例输入1

6Finding the Shortest Path120Finding the k Shortest Path80Find Augmenting Path in General Graph80Matching in Bipartite Graph200Finding kth Shortest Path50Graph Theory and its Applications406shortest pathk shortest pathgraphpathfindapplication0

样例输出1

Finding the Shortest Path
Finding the k Shortest Path
Finding kth Shortest Path
***
Finding the k Shortest Path
***
Matching in Bipartite Graph
Find Augmenting Path in General Graph
Graph Theory and its Applications
***
Finding the Shortest Path
Finding the k Shortest Path
Find Augmenting Path in General Graph
Finding kth Shortest Path
***
Find Augmenting Path in General Graph
***
***
---

样例输入2

1
Finding the Shortest Path
120
2
Path

Pat
0

样例输出2

Finding the Shortest Path
***
***
---

解题思路

首先要说明的是，样例2原题里是没有的，而个人认为中间的空行是多余的，删掉之后才能得到期望输出。

这题就是个大模拟，思路其实不是很难找，但是要写好还是很费精力和时间的。

我定义了一个paper类，包含名字、关键词数组、关键词个数和引用次数，还包含一个成员函数，负责将名字转换成关键字。所有的这些都是public。分隔符是空格，那么使用字符串流来转换很方便，只需要调用自行实现的全部转小写的函数将名字转换后推入流，再一个个推出即可。

比对关键字的时候，查找的关键字要全部在某一文献的关键字列表里，才能算找到了合适的结果，不能够使用string的find() 成员函数查找子串。

将论文全部输入之后直接使用stable_sort和自定义比较函数排序，就不需要找到符合条件的论文之后存储起来再排序了。

此题数据特别多，要格外注意各数据的初始化问题！

9. 字符串压缩

来源：Codeforces 1120C

个人难度评级：6

问题描述

给定一个由n个小写字母组成的字符串s，需要使用最少数量的钱币来压缩它。

压缩该字符串，必须将s表示为多个相互连接的非空字符串: s=t1t2…tk，其中第i个字符串按照下列两种方法之一编码：

如果 | ti|=1，也就是说 ti为单个字符组成的字符串，编码时需要支付a个钱币
如果ti是t1t2…ti-1的子串，编码时需要支付b个钱币

你的任务是计算压缩给定的字符串需要花费的最小钱币数。

输入形式

输入的第一行包含3个用空格分隔的正整数：n、a和b(1≤n、a、b≤5000)，第二行为一个长度为n的小写字符串。

输出形式

输出一个整数，表示你需要为压缩s所需要支付的最小钱币数。

样例输入1

3 3 1
aba

样例输出1

样例输入2

4 1 1
abcd

样例输出2

样例输入3

4 10 1
aaaa

样例输出3

解题思路

不会，DP题谁会做谁做去。

10. 拼写检查

来源：POJ 1035

个人难度评级：2

问题描述

       作为一个新的拼写检查程序开发团队的成员，您将编写一个模块，用已知的所有形式正确的词典来检查给定单词的正确性。
       如果字典中没有这个词，那么可以用下列操作中的一个来替换正确的单词（从字典中）：
       1. 从单词中删除一个字母；
       2. 用一个任意字母替换单词中的一个字母；
       3. 在单词中插入一个任意字母。
       你的任务是编写一个程序，为每个给定的单词找到字典中所有可能的替换。

输入形式

输入的第一部分包含所有字典中的词，每个单词占用一行，以一个单一字符 “#” 作为结束。所有单词都不相同，字典中至多1000个单词。

接下来的部分包含所有需要进行检查的单词，同样每个单词占用一行。这部分也以一个单一字符 “#” 作为结束。至多有50个单词需要检查。

在输入中所有的单词（字典中的和需要检查的）都仅由小写字母组成，每个最多包含15个字符。

输出形式

对于每个在输入中出现的单词，按照它们在输入的第二部分出现的顺序输出一行。如果该单词是正确的（也就是说它包含在字典中）则输出信息：“is correct”；如果该单词不正确，则首先输出该单词，然后输入符号 ‘:’（冒号），之后空一格，写出它所有可能的替代，以空格分隔。这些替代的单词按照它们在字典中（输入的第一部分）出现的顺序写出。如果没有可替代的单词，则在冒号后面直接输出换行。

样例输入

iishashavebemymorecontestmetooifaward#meawaremcontesthavooorifimre#

样例输出

me is correctaware: awardm: i my mecontest is correcthav: has haveoo: tooor:i is correctfi: imre: more me

解题思路

先把字典中的词语存到数组里，然后再逐个询问比对即可。难点在于删除和增加字母的检查。增删字母的判断函数可以共用，只需将函数的两个参数对调即可。修改的要求是长度相同，而增删的长度差只能为1。

11. 最小的k个数

个人难度评级：1

问题描述

输入n个整数，找出其中最小的k（k<=n）个不同数。例如输入4,5,1,6,1,7,3,8这8个数字，则最小的4个数字是1,3,4,5。

输入形式

每个测试案例包括2行：

第一行为2个整数n，k(1<=n，k<=200000)，表示数组的长度。

第二行包含n个整数，表示这n个数，数组中的数的范围是 [0,1000 000 000]。

输出形式

对应每个测试案例，输出最小的k个数，并按从小到大顺序打印 (如果不存在k个不同的数，则按照实际数量进行输出)。

样例输入

8 4
4 5 1 6 2 7 3 8

样例输出

1 2 3 4

训练提示

1、数的范围从0到1000000000，使用数组记录那些数出现过就不是太合适

2、需要去除重复的数，需要从小到大排序 —-set就是一个不错的选择

解题思路

没必要专门去重，更没必要用什么set，直接存数组sort一遍过。只需要检查上一个数是否与要输出的数相等，相等即跳过，就顺便完成了去重。

12. 绩点计算

个人难度评级：1

问题描述

学校对本科生的成绩施行绩点制（GPA）。将学生的实际考分根据不同学科的不同学分按一定的公式进行计算。规定如下：

实际成绩绩点

90-100 4.0

85-89 3.7

82-84 3.3

78-81 3.0

75-77 2.7

72-74 2.3

68-71 2.0

64-67 1.5

60-63 1.0

60以下 0

1. 一门课程的学分绩点 = 该课绩点 * 该课学分

2. 总评绩点 = 所有学科绩点之和 / 所有课程学分之和

现要求你编程求出某人的总评绩点 (GPA)

输入形式

第一行总的课程数n

第二行相应课程的学分（两个学分间用空格隔开）

第三行对应课程的实际得分

此处输入的所有数字均为整数

输出形式

输出有一行，总评绩点，保留两位小数

样例输入

5
4 3 4 2 3
91 88 72 69 56

样例输出

2.52

解题思路

不讲了，太简单。

要是得绩点也能像这道题这么简单就好了。

13. xxx定律

个人难度评级：1

问题描述

对于一个正整数n，如果是偶数，就把n砍掉一半；如果是奇数，把n变成3*n+ 1后砍掉一半，直到该数变为1为止。
请计算需要经过几步才能将n变到1，具体可见样例。

输入形式

测试包含多个用例，每个用例包含一个整数n, 当n为0时表示输入结束。（1<=n<=10000）

输出形式

对于每组测试用例请输出一个数，表示需要经过的步数, 每组输出占一行。

样例输入

3
2
0

样例输出

5
1

解题思路

太水了…… 这题我连打表都懒得打。

14. 数的距离差

个人难度评级：1

问题描述

给定一组正整数，其中最大值和最小值分别为Max和Min, 其中一个数x到Max和Min的距离差定义为：

$ | | x-Max | -(x-Min) | $

其中abs() 为求一个数的绝对值

输入形式

包括两行，第一行一个数n，表示第二行有n个正整数

输出形式

输出一个数x，该数在所有n个数中的距离差最小；如果有两个数的距离差都是最小，输出较小的哪个

样例输入1

5
3 1 7 5 9

样例输出1

样例输入2

3
1 3 2

样例输出2

解题思路

没啥难的，录进来sort一遍，逐个算距离差再比较即可。

有一个不成熟的猜想：距离差最小的，并不是中位数，而是与绝对值相差最小的数。

15. 亲和数

来源：HDU 2040（无法访问请看 Vjudge 或者Wayback Machine）

个人难度评级：1

问题描述

古希腊数学家毕达哥拉斯在自然数研究中发现，220的所有真约数 (即不是自身的约数) 之和为：

$ 1+2+4+5+10+11+20+22+44+55+110＝284 $

而284的所有真约数为1、2、4、71、142，加起来恰好为220。人们对这样的数感到很惊奇，并称之为亲和数。一般地讲，如果两个数中任何一个数都是另一个数的真约数之和，则这两个数就是亲和数。
你的任务就编写一个程序，判断给定的两个数是否是亲和数。

输入形式

输入若干行数据（大于0），每行一个实例, 包含两个整数A,B；其中0 <= A,B <= 600000 ;

输出形式

对于每个测试实例，如果A和B是亲和数的话输出YES，否则输出NO

样例输入

220 284
100 200

样例输出

YES
NO

解题思路

没啥难的，不说了

16. 金币

来源：NOIP 2015 普及组第一题（数据已加强）（卧槽竟然是NOIP的题…… 要不是当年我做过我还真想不到）

个人难度评级：2

问题描述

国王为他的忠诚的骑士支付金币。在他服役的第一天，骑士收到一枚金币。在接下来2天（第二天和第三天的服务），骑士每天收到2金币。在未来三天（第五，第四，和第六天的服务），骑士每天收到三金币。在未来四天（第七，第八，第九，和第十天的服务），骑士每天收到四金币。这一模式的付款方式将继续下去：在接下来的n天骑士每天将收到n枚金币，而在接接下来的n+1天每天将收到n+1枚金币，这里n是正整数。你的程序将确定在任何给定的天数（从第1天开始）支付给骑士的金币总数。

输入形式

输入包含至少一行，但不超过21行。输入的每一行包含一个测试案例的数据，即一个整数（1~10000），代表天数。

输出形式

每一行输出对应一个测试用例，由天数和支付给骑士的金币总数量组成，中间用空格分隔。

样例输入

样例输出

10 30
6 14
10000 942820
1000 29820
21 91
22 98

解题思路

就是个模拟题，按照题意模拟下去即可，不需要花里胡哨的方法即可解决。

17. 小A的计算器

个人难度评级：1

问题描述

以往的操作系统内部的数据表示都是二进制方式，小A新写了一个操作系统，系统内部的数据表示为26进制，其中0-25分别由a-z表示。
现在小A要在这个操作系统上实现一个计算器，这个计算器要能实现26进制数的加法运算。你能帮小A实现这个计算器吗？

输入形式

输入的第一行包括一个整数N(1<=N<=100)。
接下来的N行每行包括两个26进制数x和y，它们之间用空格隔开，每个数的位数最多为10位, 我们可以保证相加的结果的位数最多也是10位。每个数会用小A所设计的操作系统中的表示方法来表示，如：bsadfasdf。即每个数的各个位均由26个小写字母a-z中的一个来表示。

输出形式

输出x和y相加后的结果，结果也要用题目中描述的26进制数来表示。

样例输入

4
ba cd
c b
b c
ba c

样例输出

dd
d
d
bc

解题思路

高精度加法 + 进制转换。

先用string输入，然后将 ** 每一位 ** 转换为十进制数之后倒序导入vector存储。位数不足的记得补0。设置一个进位的临时数组，然后按照竖式计算方法计算，之后再转换回26进制倒序导入string输出。

18. 小丑排序

来源：ACM/ICPC 2004（贝勒大学原题面存档）

个人难度评级：1

问题描述

你在信天翁马戏团（是的，它是由一群小丑组成）从事管理工作，你刚刚写完一个程序的输出是将他们的姓名按长度为非递减的方式排列，名称列表（使每名至少只要它之前的）。然而，你的老板不喜欢这种输出方式，而是希望输出出现更对称，较短的字符串在顶部和底部，而较长的字符串在中间。他的规则是，每一对名称都是在该列表的相对的两端，并且在该组中的第一个名字总是在列表的顶部。比如在下面的第一个例子中，Bo和Pat是第一对，Jean和Kevin是第二对，等等。

输入形式

输入由1到多个字符串集合组成，最后一行为0表示输入结束，每个集合开始于一个整数n，表示该集合字符串的个数，接下来n行由n个字符串按长度非递减的方式排列，每个集合至少包含一个但不超过15个字符串，每个字符串不超过25个字符。

输出形式

对于每个集合，第一行输出 “set-n”, n从1开始，接下来的若干行对应输入每个集合重新排列的结果，如样例所示。

样例输入

7
Bo
Pat
Jean
Kevin
Claude
William
Marybeth
6
Jim
Ben
Zoe
Joey
Frederick
Annabelle
5
John
Bill
Fran
Stan
Cece
0

样例输出

set-1
Bo
Jean
Claude
Marybeth
William
Kevin
Pat
set-2
Jim
Zoe
Frederick
Annabelle
Joey
Ben
set-3
John
Fran
Cece
Stan
Bill

解题思路

看不懂题面？哦上帝，这该死的翻译，我真想用隔壁约翰叔叔的靴子狠狠踢他的屁股！说真的，这直译还不如看英文原版。

这不是排序题，题目顺序已经排好了！只要隔一个压一个栈，剩下的原样输出即可。

19. 数圈

个人难度评级：1

问题描述

以1为中心，用2,3,4, …, n, …, n*n的数字围绕着中心输出数圈，如若n=4，则

7 8 9 10

6 1 2 11

5 4 3 12

16 15 14 13

输入形式

一个整数n(1<=n<=10)

输出形式

数圈矩阵

样例输入

样例输出

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

解题思路

打表专用题，这题打表不光评测的时候输出快，而且写代码也又快又省力，我觉得打表才是这题的正解（逃）。

每个n对应的圈，实际上都可以看作n=10的子圈，所以把n=10的情况打成表如下，然后再记录每个n要把哪一块切下来输出即可。附上完整数表：

int numCircle[10][10] = {
    {73, 74, 75, 76, 77, 78, 79, 80, 81, 82},
    {72, 43, 44, 45, 46, 47, 48, 49, 50, 83},
    {71, 42, 21, 22, 23, 24, 25, 26, 51, 84},
    {70, 41, 20, 7, 8, 9, 10, 27, 52, 85},
    {69, 40, 19, 6, 1, 2, 11, 28, 53, 86},
    {68, 39, 18, 5, 4, 3, 12, 29, 54, 87},
    {67, 38, 17, 16, 15, 14, 13, 30, 55, 88},
    {66, 37, 36, 35, 34, 33, 32, 31, 56, 89},
    {65, 64, 63, 62, 61, 60, 59, 58, 57, 90},
    {100, 99, 98, 97, 96, 95, 94, 93, 92, 91}};

20. 锤子剪刀布

个人难度评级：1

问题描述

大家应该都会玩 “锤子剪刀布” 的游戏。现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。

输入形式

输入第1行给出正整数N（<=105），即双方交锋的次数。随后N行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C代表 “锤子”、J代表 “剪刀”、B代表 “布”，第1个字母代表甲方，第2个代表乙方，中间有1个空格。

输出形式

输出第1、2行分别给出甲、乙的胜、平、负次数，数字间以1个空格分隔。第3行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有1个空格。如果解不唯一，则输出按字母序最小的解。

样例输入

10
C J
J B
C B
B B
B C
C C
C B
J B
B C
J J

样例输出

5 3 2
2 3 5
B B

解题思路

这种水题挺讨厌的，完全没难度，但很占用时间（我写了1.7KiB，有这时间干啥不好？）。

21. 新型冠状病毒（COVID19）传播

个人难度评级：4

问题描述

在以习近平同志为核心的党中央的正确领导下，我国新冠疫情得到了有效控制。防控新冠病毒，必须时刻引起大家的足够重视，特别是人员集中活动场所，保持好社交距离。

然而，在大洋彼岸的 $M$ 国，人们对COVID19并未引起足够重视，他们的领导人川建国同志甚至对居家隔离、戴口罩以及保持社交距离等措施非常不屑，该国疫情已经完全失控。

在一个风景秀丽的小镇，一天早上，有 $N$ 名晨跑爱好者（编号 $1-N$）沿着优雅的江边景观道朝同一方向进行晨跑，第 $i$ 名跑者从位置 $S_i$ 处起跑，且其速度为 $V_i$。换句话说，对所有的实数 $t \ge 0$，在时刻 $t$ 时第 $i$ 名跑者的位置为 $S_i+V_i \cdot t$。

很不幸的是，其中一名跑者在 $t=0$ 的时刻感染了病毒，且是无症状感染者，这种病毒只会在同一时刻处在同一位置的跑者之间传播，新感染了病毒的跑者也会感染其他人，很显然，等待足够长的时间，那么病毒会感染一些特定的跑者。

事后发现其中有一名跑者感染了新冠病毒，如果此人就是在 $t=0$ 时刻的那名感染者，那么，在 $N$ 名晨跑爱好者中会有多少人感染新冠病毒？

输入形式

输入包含三行：

第一行包含为两个整数 $N$ 和 $K$，分别表示运动员的人数以及开始时感染了病毒的跑者编号。
第二行包含 $N$ 个正整数 $S_1$、$S_2$、…、$S_N$，用空格隔开，分别表示跑者的起始位置。
第三行包含 $N$ 个正整数 $V_1$、$V_2$、…、$V_N$，用空格隔开，分别表示跑者的速度。

输出形式

输出为一个整数，表示最终被感染人数。

样例输入

6 3
3 9 8 5 7 5
6 6 5 4 6 3

样例输出

评分标准

对于50% 的评测用例，$0 \lt K \le N \le 102$

对于70% 的评测用例，$0 \lt K \le N \le 104$

对于90% 的评测用例，$0 \lt K \le N \le 106$

对于100% 的评测用例，$0 \lt K \le N \le 107$

详细题解

这题似乎有点意思，是道自创题，值得好好说一说。不过由于本人数学过于弱鸡，这里并没有严格的数学证明。

起初的想法是，对于每一个人的行动路线，可以画出一条一次函数_yi=si+vi*t_。只要遍历一遍其他跑者，与被感染者直线在y轴右侧会相交（下文”相交 “均指y轴右侧）的，就是被感染的人，是一个O(n) 的算法。因为相遇距离设定可以是无限远，所以不能枚举距离模拟跑的过程。得了20分。

核心是用下面的函数判断两条直线是否相交，也就是是否会被感染。Pos 指的是初始位置，也就是y轴截距，而 Speed 代表速度，也就是斜率。

cpp

bool checkInfection(const int &sourcePos, const int &sourceSpeed, const int &targetPos, const int &targetSpeed)
{
    if ((sourcePos> targetPos && sourceSpeed <targetSpeed) || (sourcePos < targetPos && sourceSpeed> targetSpeed) || (sourcePos == targetPos))
    {
        return true;
    }
    else
    {
        return false;
    }
}

然后重新看题面，发现有一句话：新感染了病毒的跑者也会感染其他人。于是就想到一轮一轮感染，每轮都将每个没感染的人与每个已经感染的人对应的直线作比较，如果相交则将其加入已感染的集合；以此循环，直到某一轮没有人被传染。有Floyd-Warshall算法的感觉，是不是？看了眼数据范围，好家伙，107，我这O(n3) 的算法还是迟早歇着吧。不过粗略来看，应该能过50% N<=100的数据。

于是开始研究一层循环就能搞定的方法，将时间复杂度压缩到O(n)。我们刚刚提到，一个人的直线只要与感染者所在的直线相交，那么他肯定会被感染。那么，一个跑得快的感染者也可以感染遇到的跑得比香港记者还快更快的感染者，一个跑得慢的感染者也可以感染遇到的跑得更慢的感染者。最终，就体现在被感染的人中，有一个跑得最快的，和一个跑得最慢的，他们在_x-t_图上组成了类似于上界和下界的一个区域，如下图。

那两条蓝线代表了不断传染最快和最慢的人的过程，落实到程序上也就是维护两个speed和position的下标值，分别代表跑得最快和最慢的人，初始值均为0号患者（即初始被感染的人），如果有能和最快的人对应直线相交且speed更大的人，说明能够传染他，将值更新为这个人对应的下标值，正如图中上方曲线的两次弯折；对跑得最慢的人也是同样的处理办法。

发现什么了吗？这个上界和下界，就是会不会被传染的界限。不过，既然直线可以无限延伸，那么我们可以去掉中间逐渐感染的过程，直接感染最快和最慢的那两个人，就变成了这样：

前后两种方式，虽然过程不同，但感染的结果是等效的。代表最快最慢的直线，一定会与0号感染者直线相交，那么只需要一直选取和0号感染者直线相交，而且比最快更快 / 比最慢更慢的人来更新最快 / 最慢下标值即可，而不需要每次都比较”和最快直线相交 “且” 比最快更快 “，或者” 和最慢直线相交 “且” 比最慢更慢“，省下一次比较。

判断是否穿过这两条折线共三条直线，分两种情况：

第一种是判断是否与0号感染者的直线相交；
第二种是判断是否与后面2条直线相交。

满足一种就会被传染。我们刚刚需要一次循环来找最快最慢的跑者，判断这些直线是否与0号直线相交，那么对于相交的直线可以直接打上infected标记，顺便进行第一种情况判断，无需进行第二种判断（直接continue）。第二步的标准又可以转化为”不在上界直线的上方 “且” 不在下界直线的下方“，其中上方和下方指的是在y轴右侧，函数值永远更大 / 更小，自然也不会相交。

还记得刚刚那个判断函数吗？我将它改成了下面的样子：

cpp

int checkInfection(const int &sourcePos, const int &sourceSpeed, const int &targetPos, const int &targetSpeed) // 返回值：1 - 在上方 0 - 相交 -1 - 在下方
{
    if ((sourcePos> targetPos && sourceSpeed <targetSpeed) || (sourcePos < targetPos && sourceSpeed> targetSpeed) || (sourcePos == targetPos))
    {
        return 0;
    }
    if ((targetPos> sourcePos) && (targetSpeed>= sourceSpeed))
    {
        return 1;
    }
    return -1;
}

这样在一个函数里，可以一次判断target直线位于source直线上方、下方还是相交。关于它的理解，可以画个图。

然后统计被打上标记的人数量（可以合在第二种情况判断的函数一起完成），输出即可。

总共四次循环，都为1层，也就是O(n) 的复杂度，其中两层循环还是输入数据用的。

湖南大学 2021 程序设计训练笔记 - 作业训练 1

Mon, 05 Jul 2021 00:00:00 +0000

作业训练1

1. 众数

个人难度评级：1

问题描述

一组数据中出现最多的数，称为众数。比如

1 2 3 3

众数为3。一组数据中也可能有多个众数，以最先出现的作为众数。比如

2 2 3 3

众数为2。

问题是一组按升序排好的数据，指出它的众数。

输入形式

有多组测试数据（不超过100组测试数据）。

每组测试数据占两行，第一行是正整数N：表示这组测试数据中数据项数。

第二行是N个用空格隔开的正整数，表示这组测试数据的数据元素。每个数据元素都不大于10000。

N=0，表示输入结束，并且不需要处理。

40% 的测试数据N 1 ≤N≤ 10；

30% 的测试数据N 10 < N≤ 100；

20% 的测试数据N 100 < N≤ 1000；

10% 的测试数据N 1000 < N≤ 10000；

输出形式

对于每组测试数据，输出一行包含一个正整数：对应的众数。

样例输入

text

样例输出

text

1
2

3
2

解题思路

使用桶排序的思想，设一个数组，存储每个数的出现次数。再遍历这个数组，取最大值。

数据是按升序排好的，所以也许一遍循环能走完，而且能省下桶排的数组空间？

2. 错误的里程碑

个人难度评级：2

问题描述

三月八日，小明买了台新车。但很快小明发现汽车的里程表有问题：里程表上每一位都不显示数字3和数字8，也就是说直接从数字2跳到数字4，直接从数字7跳到数字9。小明纳闷：这车到底行驶里程是多少。

现在，小明向你求助：根据里程表显示的数字，给出真实的行驶里程。

输入形式

输入有多组测试数据。

输入第一行正整数T，表示有多少组测试数据。

后面有T行，每行一个非负整数，表示里程表显示数字，里面不含有数字3和8。该数字不超过10位。

40% 的测试数据组数T 10≤T≤ 102；

30% 的测试数据组数T 102≤T≤ 103；

20% 的测试数据组数T 103≤T≤ 104；

10% 的测试数据组数T 104≤T≤ 105；

输出形式

对于每组测试数据，输出一个整数占一行：真实的行程里程。

样例输入

text

样例输出

text

解题思路

实际上这是一个8进制里程表，因为只有0、1、2、4、5、6、7、9，也就相当于0、1、2、3、4、5、6、7。做一个八进制转十进制即可。可能需要使用long long类型。

3. 拳王阿里

此题有些问题，暂不处理。

4. 欧洲冠军联赛

个人难度评级：2

问题描述

欧洲冠军联赛常被誉为全世界最具影响力的俱乐部级赛事。在比赛的小组赛阶段，欧洲的各个足球俱乐部被分为八个小组，每个小组中四支球队。每个小组中的球队按照如下规则排序：

球队会根据比赛结果获得积分。一场比赛的双方被称为主队和客队。如果其中一方进球数多于另一方，那么进球较多的一方获得3分，另一方获得0分。如果双方打成平手，则各得1分。
球队的净胜球数是其进球数减去失球数（不考虑该球队在比赛中作为主队还是客队）。
积分较高的球队排名更加靠前。
如果两支球队积分相同，那么净胜球数较多的球队排名靠前。

小组的各队伍进行循环赛，即每两支球队之间进行两场比赛，双方交替作为主队。给定一个小组内12场比赛的结果，请求出小组的出线队伍：即排名第一和第二的两支球队。

保证答案唯一。

输入形式

输入的第一行包含一个整数T，代表测试数据的组数。接下来是T组数据。

每组数据共有12行，每行描述一场比赛，格式为：“主队队名主队进球数vs. 客队进球数客队队名”，其中 “主队队名” 和“客队队名”为字符串，“主队进球数”和 “客队进球数” 为两球队在本场比赛中各自的进球数量。

1 ≤ T ≤ 50
球队队名仅包含小写英文字母
球队队名长度不超过10个字符
0 ≤ 进球数 ≤ 100

输出形式

对于每组数据，输出一行，包含两个字符串，代表排名第一和第二的球队的队名。

样例输入

text

2
manutd 8 vs. 2 arsenal 
lyon 1 vs. 2 manutd 
fcbarca 0 vs. 0 lyon 
fcbarca 5 vs. 1 arsenal 
manutd 3 vs. 1 fcbarca 
arsenal 6 vs. 0 lyon 
arsenal 0 vs. 0 manutd 
manutd 4 vs. 2 lyon 
arsenal 2 vs. 2 fcbarca 
lyon 0 vs. 3 fcbarca 
lyon 1 vs. 0 arsenal
fcbarca 0 vs. 1 manutd
a 3 vs. 0 b 
a 0 vs. 0 c 
a 0 vs. 0 d 
b 0 vs. 0 a 
b 4 vs. 0 c 
b 0 vs. 0 d 
c 0 vs. 0 a 
c 0 vs. 0 b 
c 1 vs. 0 d 
d 3 vs. 0 a 
d 0 vs. 0 b 
d 0 vs. 0 c

样例输出

text

1
2

manutd fcbarca 
d b

样例说明

第一组数据：每支球队的积分与净胜球数分别为：

manutd：16分，净胜球数12。
manutd：8分，净胜球数4。
manutd：5分，净胜球数 −5。
manutd：4分，净胜球数 −11。

第二组数据：每支球队的积分与净胜球数分别为：

d：7分，净胜球数2。
b：7分，净胜球数1。
a：7分，净胜球数0。
c：7分，净胜球数 −3。

所有球队的积分相同，但是净胜球数较多的队伍排名更加靠前。

解题思路

使用结构体存储球队的名称、净进球数和得分，使用一个结构体数组存储所有球队信息。

注意找不到已记录球队就新建球队的操作。

5. 合法的括号串

个人难度评级：3

问题描述

一个合法的括号串，是指只包含括号的串，如果满足如下条件：

（1）<> () [] {} 这四对括号是合法的；

（2）如果r是合法括号串，则 <r> (r) [r] {r} 也是；

（3）如果r，s是合法括号串，则rs也是；

所以 «» , [<>{}(())],[({<>})] 是合法的括号串，而)(,[( ])就不是。

输入形式

输入第一行正整数t (10 ≤ n ≤ 100)，表示有多少组测试数据。

后面有t行，每行一个只包含8种括号符号的括号串。

40% 的括号串的长度L 2 ≤ L≤ 20；

30% 的括号串的长度L 2 ≤ L≤ 200；

20% 的括号串的长度L 2 ≤ L≤ 2000；

10% 的括号串的长度L 2 ≤ L≤ 20000；

输出形式

对于每组测试数据，如果括号串是合法的，输出 “Yes”（输出没有引号）占一行，否则，输出 “No”（输出没有引号）占一行。

样例输入

text

6
<<>> 
)(
[<>{}(())]
[({<>})]
[(])
<([{

样例输出

text

Yes
No
Yes
Yes
No
No

解题思路

括号配对是老例题了。使用栈来存储前面未配对的左括号，遇到右括号检验一下是否匹配，然后弹栈。惟需注意：

整组数据算完之后将栈清空，否则下一组即使匹配，最后也会栈内还有元素而不匹配；
弹栈之前检测栈空，这个应该很容易看出来，一般样例就能反映。

6. 世界杯来了

个人难度评级：3

问题描述

2018年俄罗斯世界杯结束了，法国获得冠军，全世界球迷度过了一个非常愉快的夏天。作为中国球迷，不能总是看别人踢球，这不福利来了，根据FIFA（国际足联）及全体成员协会的一致决定，2118年世界杯将在中国举办，作为东道主，中国队将无需参加预选赛而直接参加决赛阶段的比赛。

比赛规则如下：

总共n（n为偶数）个球队参加比赛
按照分组赛积分排名，前n/2的球队进入淘汰赛
积分排名的规则如下：球队获胜得3分，平局得1分，失利得0分，按照积分递减、净胜球递减以及进球数递减方式排名编写一个程序，根据给出的参赛队伍名单和所有比赛的结果，找出成功进入淘汰赛阶段的球队名单。

输入形式

第一行输入包含唯一整数n(1<=n<=50)，参加世界杯决赛的球队数量。接下来的n行是各球队的名字，为长度不超过30个字符的英文字符。接下来的n*(n-1)/2行，每行格式name1-name2 num1:num2（0<=num1, num2<=100），表示对阵球队及比分.

输出形式

输入n/2行，表示进入淘汰赛阶段的球队，按照字典序进行排列，每个球队名字占一行

样例输入

text

`1`	`4ABCDA-B 1:1A-C 2:2A-D 1:0B-C 1:0B-D 0:3C-D 0:3`

样例输出

text

AD

解题思路

跟第4题整体思路差不多，增加了一点难度主要在字符串的分割上。只要掌握根据分隔符将字符串分割成两半的方法就行。

7.F1方程式冠军

个人难度评级：3

问题描述

一级方程式F1锦标赛由一系列称为大奖赛的分站赛组成。每一场比赛的车手都根据他们的最后位置获得积分。只有前10名车手按以下顺序获得分数：25、18、15、12、10、8、6、4、2、1。在锦标赛结束时，得分最多的车手是冠军。如果有平分，则冠军是赢的最多的人（即排位第一）。如果还是平分，则选择得到排位第二最多的人，依此类推，直到没有更多的排位进行比较。

后来又提出了另一个得分制度，其中冠军是赢的最多的。如果有平手，冠军是得分最多的。如果仍然存在平手，则按原来的得分制度进行，即比较第二、第三、第四、… 排位的次数。

在本赛季，你会得到所有比赛的结果，你将根据两个得分系统来分别确定冠军。数据保证两套系统都能得到唯一的冠军。

输入形式

第一行一个整数t（1<=t<=20），t是分站赛的场次数。之后是每个分站赛的最终排位情况，每个的第一行一个整数n(1<=n<=100) 表示排位车手人数，之后n行按排位列出车手的名字，排位从第一到最后，车手的名字为长度不超过50的英文字符，大小写区分。

输出形式

输出为两行，第一行为按照原始规则确定的冠军，第二行是按照可选规则确定的冠军。

样例输入

text

`1`	`33applebananapear2pearbanana2applebanana`

样例输出

text

`1`	`bananaapple`

解题思路

和第4题差不多的壳，但主要考察的是结构体的排序，手写不同的比较函数是重点。

注意比较的时候最多可能比较到得到10-20名的次数，所以得到某名次计数的数组要开得大些。

8. 买房与选房

个人难度评级：7

问题描述

在 X 国许多一线城市住房非常紧张，政府部门制定了相关的政策，重点满足住房刚性需求（住房面积为0，社保缴纳必须超过2年），然后才能照顾改善性需求（住房面积大于0）。

具体的原则为：

对于刚性需求，缴纳社保月数多者优先
对于改善性需求，现有自有住房面积小者优先

由于房源有限，为公平起见，开发商在不违背上述原则下特意指定同等条件下申报时间同时作为排队的条件，时间越早优先级越高。

最近有一批新楼盘准备开盘，总共有 m （≤1000）套房，所有的网上申报工作都已经完成并保存到二进制文件house.bin中，申请者提交了自己的基本材料，格式为：身份证号（18位，加1位空字符 ‘\0’，共19位）、社保缴纳月数、自有住房面积、申报时间 (格式为：MM-DD-YYYY，10位字符串，加1位空字符’\0’，共11位)，社保缴纳月数、自有住房面积均为整数，文件最后为总报名人数 n（≤105）。

申请者可以通过身份证号查询最终的结果。

输入形式

输入的第一行为两个正整数 m（≤1000）和 T （ **T_ ≤ n**_ ），分别表示本次开盘的楼盘可供申请的套数以及查询的组数

接下来的 T 行，每行为一个18位的字符串，表示需要查询的身份证号

输出形式

输出为 T 行，对应每个查询的输出结果：

1. 申请者不符合购房条件或排位超出了所推出的房源数量不能中签，则输出 “Sorry”;

2. 申请者符合购房条件，且该名次人数为1人，则直接输出一个整数，表示选房顺序号;

3. 申请者符合购房条件，且该名次人数有多人，同时人数不大于所剩房源数量，则直接输出用空格分隔的两个整数，表示选房顺序号区间;

4. 申请者符合购房条件，且该名次人数有多人，同时人数大于所剩房源数量，则输出用 / 分隔两个整数，如 A/B，表示 B 人中选 A 人，选房顺序为排名倒数 A 名范围。

样例输入

text

9 6
350102200609166049
350102200609163286
250342323545313434
130502201805070787
110101196003074525
430102201102181455

样例输出

text

2
3 4
Sorry
6
2/3
Sorry

代码框架

** 建议复制以下代码框架，在此基础上完成本题需求。此建议不是必须，你可以忽略。**

cpp

#include <iostream>

using namespace std;

struct people

{

    char id[19];                  /* 身份证号码 */

    int social;                     /* 社保缴纳月数 */

    int area;                       /* 现有住房面积 */

    char date[11];              /* 申报日期 */

};

people* getMess(int &n);

int main()

{

    people *person;          /* 指向所有报名人的基本资料首地址，通过调用函数 getMess 获取 */     

    int n;                            /* n 为报名人数，通过调用函数 getMess 获取 */

    person=getMess(n);



    // ...



    return 0;

}

people* getMess(int &n)            /* 将文件数据读入内存 */

{

    FILE *fp;

    fp=fopen("house.bin","rb");

    fseek(fp,-1*(long)sizeof(int), 2);

    fread(&n, sizeof(int),1, fp);

    rewind(fp);

    people *tmp=new people[n];

    fread(tmp, sizeof(people), n, fp);

    fclose(fp);

    return tmp;

}

测试用例说明

10% 的用例无同等条件的数据，30% 的用例只有刚性需求，20% 的用例只有改善性需求。

文件下载

请下载压缩文件（见CG平台）并在存放源程序文件的文件夹下解开，其中二进制文件house.bin包含了相关的测试数据，test.txt是相关测试数据的文本格式，可用于程序测试。

解题思路

我引入了一个”优先级 “整型变量来决定排到房源的优先级，使这个变量必满足刚性需求社保久> 刚性需求社保少>改善需求小房子>改善需求大房子>没有购房资格，在此顺序绝对成立的基础上，申请早的优先级高。这个可以从我的代码里详细了解。

然后，将其与对应的people结构体组成pair并使用stable_sort排序，按优先级从大到小。这样就可以很容易地得到某个人的名次和同名次人的范围。

我的代码一个点都没过，但我觉得我的思路是对的……

9. 二叉树遍历，从前序、中序到后序

个人难度评级：4

问题描述

二叉树是一种非常重要的数据结构，非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树，深度遍历有前序、中序以及后序三种遍历方法。

三种基本的遍历思想为：

前序遍历：根结点 —> 左子树 —> 右子树

中序遍历：左子树 —> 根结点 —> 右子树

后序遍历：左子树 —> 右子树 —> 根结点

比如，求以下二叉树的各种遍历

前序遍历：1 2 4 5 7 8 3 6

中序遍历：4 2 7 5 8 1 3 6

后序遍历：4 7 8 5 2 6 3 1

需要你编写程序解决的问题是：已知一个二叉树的前序遍历和中序遍历的结果，给出该二叉树的后序遍历的结果。

输入形式

有多组测试数据，每组测试数据三行，每组测试数据第一行只有一个正整数n，表示二叉树节点的数目，n=0意味着输入结束并且不需要处理。

每组测试数据第二行是二叉树的前序遍历的结果，是一个长度为n的字符串，每个节点由一个字符表示，字符是大小写英文字母及10个数字, 不同的节点用不同的字符表示，也即无论前序遍历和中序遍历的字符串中没有重复的字符。

每组测试数据第二行是二叉树的中序遍历的结果，也是一个长度为n的字符串。

40% 的测试数据1 ≤ n≤ 10；

30% 的测试数据1 ≤ n≤ 20；

20% 的测试数据1 ≤ n≤ 40；

10% 的测试数据1 ≤ n≤ 62；

输出形式

对于每组测试数据，输出一行，是一个长度为n的字符串，表示二叉树后序遍历的结果。

样例输入

text

8
12457836
42758136
4
abcd
abcd
4
abcd
dcba
0

样例输出

text

1
2
3

47852631
dcba
dcba

解题思路

使用递归方法。对于每个子树（输入数据本身也算一棵子树），先得到根节点，然后利用其分别分割左子树和右子树并分别传入递归，最后输出根节点。

部分参考了 9. 二叉树遍历，从前序、中序到后序 (递归即可解决)_yogdzewa 的博客 - CSDN 博客。

10. 内存管理

来源：Codeforces 7B

个人难度评级：4

问题描述

离第一个操作系统HNU-OS发布已经没有多少时间了，但它的一些组件还没有完成，内存管理器就是其中之一。根据开发人员的计划，在第一个版本中，内存管理器将非常简单和直观。它将支持三个操作：

alloc n —— 分配n个字节内存，返回已分配块的正整数标识符x(x初始值为0，每次分配增长1)
erase x —— 删除标识符x所在的块
defragment —— 整理空余内存碎片，将所有块尽量靠近内存的开始位置，并保持各自的顺序

在此情况下，内存模型非常简单，它是一个m字节的序列，为了方便起见，从第一个字节到第m字节进行编号。

第一个操作alloc n有一个参数n，表示被分配的内存块大小。在处理此操作时，内存中将分配n个连续字节的空闲块。如果这些块的数量超过一个，则优先选择最接近内存开始 (即第一个字节) 的块。所有这些字节都被标记为非空闲，内存管理器返回一个32位整数数字令牌，代表该块的标识符。如果不可能分配这样大小的空闲块，则返回NULL。

第二个操作erase x以x为参数，表示某个块的标识符。此操作释放系统内存，将此块的字节标记为空闲以供进一步使用。如果此标识符没有指向先前分配的块 (该块尚未被释放)，则返回ILLEGAL_ERASE_ARGUMENT。

最后一个操作defragment没有任何参数，只会使占用的内存部分更接近内存的开始，而不会更改它们各自的顺序。

在当前的实现中，将使用从1开始的连续整数作为标识符。每个成功的alloc操作过程都应该返回接下来的编号。不成功的alloc操作不影响计数。

编写内存管理器的实现，为每个alloc命令输出返回的值，为所有失败的erase命令输出ILLEGAL_ERASE_ARGUMENT。

输入形式

输入数据的第一行包含两个正整数t和m（1<=t<=500, 1<=m<=105)，其中t表示需要内存管理器来处理的操作个数，m表示有效的内存字节大小。接下来的t行每一行代表一个操作。

输出形式

输出有多行，每行或者是alloc操作的结果，或者是失败的erase操作的结果ILLEGAL_ERASE_ARGUMENT。其顺序与输入的操作次序一致。

样例输入

text

`1`	`6 10alloc 5alloc 3erase 1alloc 6defragmentalloc 6`

样例输出

text

12NULL3

解题思路

定义memblock结构体存储内存块，包含标识符、开始点和结束点，和一个是否已经被释放的bool标记。

借鉴了堆的思想，将靠前的内存块前置，靠后的内存块后置，已经释放的内存块则放到最后面去。在插入和释放完成后进行排序，因为相对位置已经改变。

分配新内存块时，先寻找块间的剩余空间，如果不够再尝试从尾部插入，然后排序。释放时将编号对应的块记为已经释放，然后排序。碎片整理操作则是挨个移动已经有序的各个块即可。

11. 平均方差

个人难度评级：1

问题描述

一个数列的平均方差是指数列中的每个元素与数列的平均值的差的平方和的平均值，比如下面数列：

1 2 3 4 5 6 7

其平均值为4，每个元素与平均值的差的平方为

9 4 1 0 1 4 9

其平方和为28，所以该数列的平均方差为4。

对给定的数列，求出其平均方差。

输入形式

有多组测试数据。

每组测试数据第一行是一个正整数N，表示数列中元素个数，接下来一行N个用空格分隔开的正整数，表示数列的N个元素，每个元素的值都是不大于500的正整数。

N=0表示输入结束，并且不需要处理。

40% 的数列元素个数N 1 ≤ N≤ 10；

30% 的数列元素个数N 1 ≤ N≤ 100；

20% 的数列元素个数N 1 ≤ N≤ 1000；

10% 的数列元素个数N 1 ≤ N≤ 10000；

输出形式

对于每组测试数据，输出一个整数：平均方差。平均方差不是整数的，输出其向下取整的整数。比如平均方差是4.5，输出4。

样例输入

text

7
1 2 3 4 5 6 7
4
1 2 3 4
0

样例输出

text

1
2

4
1

解题思路

这玩意有啥解题思路？算就是了。记得适时用double。

12. IP地址

个人难度评级：2

问题描述

一个IP地址由32位二进制的数组成，比如：

111111111111111111111111000000002

为了便于记忆，我们将8个二进制位用一个十进制数表示，一个IP地址由四个十进制数表示，上述的IP地址表示为：

255.255.255.0

现在给你一个上述形式的IP地址，请回答IP地址的32个二进制位中，有多少位是1。

如IP地址为255.255.255.0，其中24位是1。

输入形式

有多组测试数据。

测试数据第一行是一个正整数T，表示测试数据组数。

每组测试数据是一个IP地址，形式为：

IP1.IP2.IP3.IP4

其中0 ≤IP1,IP2,IP3,IP4≤ 255, 用十进制表示。每个IP地址不保证是实用IP地址。

40% 的测试数据组数T 10≤T≤ 102；

30% 的测试数据组数T 102≤T≤ 103；

20% 的测试数据组数T 103≤T≤ 104；

10% 的测试数据组数T 104≤T≤ 105；

输出形式

对于每个IP地址，输出一行包含一个非负整数：该IP地址的32个二进制位中，1的位数。

样例输入

text

5
255.255.255.0
127.0.0.1
0.0.0.1
1.2.3.4
0.0.0.0

样例输出

text

提示：样例中32位的IP地址为：

111111111111111111111111000000002

011111110000000000000000000000012

000000000000000000000000000000012

000000010000001000000011000001002

000000000000000000000000000000002

解题思路

核心在于进制转换的思想，以及第6题分割字符串的方法。先分割再转换进制，不就很简单了吗？

13. 开关与灯

来源：CodeForces 985B（我湖不愧是9B5）

个人难度评级：2

待完善

14. 可删除的点

个人难度评级：1

问题描述

平面上有n个不同的点，没有在Y轴的点，检查是否存在这样一个点，将其删除后其余所有的点均位于Y轴的同一边。

输入形式

输入第一行包含一个正整数n(2<=n<=105)。

接下来的n行，包含所有点的坐标，第i行包含两个整数xi和yi(|xi|、|yi|<=109，xi<>0)。

输出形式

如果存在这样的点，则输入 “Yes”，否则输出 “No”。

样例输入

text

`1`	`31 1-1 -12 -1`

样例输出

text

Yes

解题思路

有一个坑点，就是如果所有点本来就在一边，也是符合要求的，别的没什么好说的。

15. 字符串反转3

个人难度评级：3

问题描述

给出一个字符串，请将其每个单词反转后输出。

输入形式

输入第一行为一个正整数N，表示测试用例数，接下来的N行，每行一个字符串。

输出形式

输出N行，每行对应一个反转后的字符串。

样例输入

text

`1`	`3olleh !dlrowm'I morf .unhI ekil .tae`

样例输出

text

`1`	`hello world!I'm from hnu.I like eat.`

解题思路

这题蛋疼就蛋疼在数据5规模相当大，用C++ 的库函数似乎很容易在第5个点超时（没错我也超了）。据大佬说，写一个仅基于C的版本能够大幅度提升效率。如果不是难以预计的TLE（数据规模都没给），这个题并不是很难。

16. n，还是n

个人难度评级：2

问题描述

输出包含n或者是n的倍数的所有数

输入形式

正整数m,n（0<m，n<1000000）

输出形式

从小到大排列的不大于m的特殊正整数（包含n，或者是n的倍数）。

样例输入1

text

20 7

样例输出1

text

7 14 17

样例输入2

text

200 11

样例输出2

text

`1`	`11 22 33 44 55 66 77 88 99 110 111 112 113 114 115 116 117 118 119 121 132 143 154 165 176 187 198`

样例说明

包含n的数可以考虑使用字符串查找解决

解题思路

数据规模不大，倍数这个条件直接 % 就行。包含这个条件可以用字符串find成员函数处理。

17. 字符串排序

个人难度评级：1

问题描述

定义一个字符串的无序度为所有位置后面的字母比该位置的字母小的总数之和。比如 “DAABEC’‘这个字符串的无序度是5，因为D后面有4个位置比它小（AABC），E后面有1个比它小（C），其它位置后面没有比自己小的。” AACEDGG “的无序度为1（E后面有一个D比它小）。” ZWQM " 的无序度为6，每个位置后面所有的字母都比它小。
现在你的任务是给定一些字符串（只由大写字母组成），把他们按照无序度从小到大排序，如果无序度一样，那么就按照输入的相对顺序排序。

输入形式

单组测试数据。
第一行有两个整数n(0 < n <= 50) 和m (0 < m <= 100)，分别表示输入的字符串的长度和字符串的个数。
接下来m行，每一行包含一个长度为n的字符串，只由大写字母组成。

输出形式

输出m行，表示排序之后的字符串。

样例输入

text

`1`	`10 6AACATGAAGGTTTTGGCCAATTTGGCCAAAGATCAGATTTCCCGGGGGGAATCGATGCAT`

样例输出

text

`1`	`CCCGGGGGGAAACATGAAGGGATCAGATTTATCGATGCATTTTTGGCCAATTTGGCCAAA`

解题思路

照着题目要求算无序度即可。我建议用pair类型分别存储字符串和无序度两个键值，然后用stable_sort自定义排序函数排序，以保持原有输入顺序。没必要排序的时候再算无序度，会很慢。

18. 三角形的面积

个人难度评级：1

问题描述

已知三角形的三个顶点的坐标，求该三角形的面积。

输入形式

有多组测试数据。

每组测试数据占一行，6个用空格分隔开的浮点数：x1,y1,x2,y2,x3,y3。表示三角形三个顶点的坐标。

一行6个0（形如0 0 0 0 0 0），表示输入结束，并且不需要处理。

40% 的顶点坐标 -10 ≤ xi,yi≤ 10；i=1,2,3

30% 的顶点坐标 -100 ≤ xi,yi≤ 100；i=1,2,3

20% 的顶点坐标 -1000 ≤ xi,yi≤ 1000；i=1,2,3

10% 的顶点坐标 -10000 ≤ xi,yi≤ 10000；i=1,2,3

输出形式

对于每组测试数据，输出对应三角形面积，保留小数点后6位。

样例输入

text

1
2
3

1 2 3 4 -2 8
0 0 0 1 1 0
0 0 0 0 0 0

样例输出

text

1
2

9.000000
0.500000

Tips：如果使用浮点数，请注意精度问题，推荐使用double

解题思路

数论题，如果会了海伦公式，很简单。

19. 循环数

来源：POJ 1047

个人难度评级：3

问题描述

循环数是n位长度的整数，当乘以从1到n的任何整数时，产生原始数字的 “循环”。也就是说，如果考虑最后一个数字之后的数字“绕” 回到第一个数字，两个数字中的数字序列将是相同的，尽管它们可能从不同的位置开始。例如，数字142857是循环的，如下表所示：

        142857 *1 = 142857
        142857 *2 = 285714
        142857 *3 = 428571
        142857 *4 = 571428
        142857 *5 = 714285
        142857 *6 = 857142

编写一个程序来确定数字是否是循环数。

输入形式

输入一个数，长度在2到60位之间 (请注意，前面的零不应该被删除，它们被认为是确定n的大小和计数的一部分，因此，“01” 是一个两位数的数字，与 “1” 是一个一位数的数字不同。) 。

输出形式

对于每个输入，输出一行 (Yes或No) 标识它是否是循环数。

样例输入

text

样例输出

text

Yes

解题思路

主要的麻烦是如何判断一个数和另一个是可以绕回来，以及如何处理60位数字的乘法问题。

事实上，如果一个序列可以分成两部分，调换顺序之后与另一个序列相等（或者进一步地，两个部分都是另一个序列的子串），那就可以” 绕回来 “。我枚举了分界线，使用std::string的substr成员函数分割字符串，并使用上文提到的find成员函数判断子串。

如此长数字的乘法，属于高精乘低精的问题，可以仿照竖式计算的方法计算。

20. 电能消耗

来源：Codeforces 10A

个人难度评级：1

问题描述

汤姆对他最喜欢的笔记本电脑的耗电量很感兴趣。他的笔记本电脑有三种模式。在正常模式下，笔记本电脑每分钟消耗P1瓦。在汤姆最后一次移动鼠标或触摸键盘后的T1分钟，屏幕保护程序启动，每分钟的功耗变化为P2瓦。最后，从屏幕保护程序启动到T2分钟后，笔记本电脑切换到 “睡眠” 模式，每分钟消耗P3瓦。当笔记本电脑处于第二或第三模式时，如果汤姆移动鼠标或触摸键盘，则切换到第一种 (正常) 模式。汤姆使用笔记本电脑工作的时间可以分为n个时间间期 [l1, r1]、[l2, r2]、…、[ln, rn]。在每个间期，汤姆连续移动鼠标并按下键盘。在间期之间，汤姆什么都不做。请找出在间期 [l1, rn]笔记本电脑的总耗电量。

输入形式

第一行包含6个整数n、P1、P2、P3、T1、T2(1<=n<=100，0<=P1、P2、P3<=100，1<=T1、T2<=60)。接下来的n行包含了汤姆工作的期间，第i行是两个用空格分隔的整数li和ri(0<=li<=ri<=1440, 当i<n时ri<li+1）, 表示工作期间的开始时间和结束时间。

输出形式

输出总的耗电量。

样例输入

text

`1`	`2 8 4 2 5 1020 3050 100`

样例输出

text

解题思路

如果要说有难点的话，就是L1和Rn的选取存储。我的办法是将第一组特殊处理，具体的可以直接看我代码。

21. 计算校验码

个人难度评级：3

问题描述

传送一个B（B≤16）进制的数值N时，最后加上一个一位（B进制的）校验码，使得N加上校验位后能被B-1整除。比如十进制的数值12310，其校验码就是3，因为十进制数值123310能被9整除。16进制的数7816，其校验码为0，因为16进制的78016是15的倍数。超过十进制后，用字母a表示10，字母b表示11，字母c表示12，字母d表示13，字母e表示14，字母f表示15。

告诉你进制B，以及一个B进制的正整数N，要求你计算正整数N在B进制下的校验码。

输入形式

输入第一行正整数t (10 ≤ n ≤ 100)，表示有多少组测试数据。

后面有t行，每行两个正整数B，N（2≤ B≤16），中间用一个空格隔开，B是10进制整数，N用B进制形式表示。测试数据保证没有非法的B进制数N（也即N中每一位都是在0到B-1之间，没有前导0）。

40% 的测试数据N的位数L 1 ≤ L≤ 10；

30% 的测试数据N的位数L 1 ≤ L≤ 102；

20% 的测试数据N的位数L 1 ≤ L≤ 103；

10% 的测试数据N的位数L 1 ≤ L≤ 104；

输出形式

对于每组测试数据，输出一位占一行：正整数N在B进制下的校验码。（如果校验码可以为B-1，也可以为0，输出0）。

样例输入

text

样例输出

text

样例说明

第一行的4表示有4组测试数据，下面四行，每行一组测试数据。

第一组测试数据10进制数123最后添加检验码3，10进制数1233是9（=10-1）的倍数

第二组测试数据16进制数78最后添加检验码0，16进制数780是15（=16-1）的倍数

第三组测试数据16进制数1234321最后添加检验码e（=14），16进制数1234321e是15（=16-1）的倍数

第四组测试数据12进制数ab最后添加检验码1，12进制数ab1是11（12-1）的倍数

【Tips】

B进制的数能被B-1整除，当且仅当各位数字和能被B-1整除。

第一组测试数据10进制数123最后添加检验码3，10进制数1233各位数字和是9，是9的倍数

第二组测试数据16进制数78最后添加检验码0，16进制数780各位数字和是15，是15的倍数

第三组测试数据16进制数1234321最后添加检验码e，16进制数1234321e各位数字和是30，是15的倍数

第四组测试数据12进制数ab最后添加检验码1，12进制数ab1各位数字和是22，是11的倍数

解题思路

获取校验码的过程，本质上是一个高精度除法，大数除小数。先将每一位用十进制整数表示（即使转换完大于10也算作一位），然后再使用竖式计算的方式算出余数，要求将其乘以10再加上校验码，除以进制 - 1能够整除。这样可以枚举从0到n-1的整数作校验码。

每一组数据完成后，一定要清空按位存储原数字的数组，否则会遗留除法计算结果，影响下一组数据计算！

不建议使用itoa函数将数字转换为二进制字符串，更推荐自己实现（反正只需要转一位，即将整型校验码转为char），因为它是GNU C++ 标准的函数，不被许多ISO C++ 的编译器支持。

此外，朋友提供了一种数论的办法：将整个数的每一位相加，再加上一个0到n-2的数，如果能够被n整除，则加上的这个数就是校验码。

HNU 校园网 IPv6 免流折腾实录

Fri, 19 Feb 2021 00:00:00 +0000

谨以此文章献给饱受校园网流量不足之苦的同学们。本实录中的步骤仅在HNU校园网环境尝试过复现，其他学校不保证可以使用。同时，理论上也不是每一步都是必要的，仅仅表明这种方法可行。

绕过校园网流量计费不代表可以不花钱上网。事实上，一台性能还凑合的路由器花了我200元，再加上服务器，每个月也要花费5美元，还有大量的隐性时间成本。一旦校园网开始真的限制40G，这篇文章的意义或许才显现出来；而为了绕过20G以上的收费，40G每个月对你够用的话，并没有必要去大费周章。

建议有一定玩机基础与一点点网络基础的人仿照着做，或者在熟悉的朋友现场指导与帮助下实施。博主对可能造成的问题不负责任，请周知。

由于本文写得实在过于杂乱，现阶段建议去阅读 HNU 校园网 IPv6 免流教程 2.0。

一

2021年新年到了，学校的个人门户也换了一副新的模样。变的不止个人门户，而且还有流量监控页面。

现在，新版的流量监控可以查看每日流量消耗，甚至上了哪家的网站都能显示出来。缴费页面也出现了前几个月的欠费信息（虽然不能缴费），让人不禁担心随时会开始计费。

直到某日，某兄透露称，流量计费系统调试好了就会开始工作，我才开始考虑如何搞到更多的流量，毕竟20G每月免费、40G每月封顶，实在是很恶心人，要是天天和宋浩老师一起学习的话怎么受得了啊。

运营商宽带固然是一个解决办法，但是价格太贵，带宽也并不高，还限制设备，所以它成了我的备选方案，而将重心放在绕开校园网的流量监测上。

二

阅读一下校园网使用规则，可以很容易地发现IPv6是免流量的。那么我们的思路就确定了：将终端全部连接至IPv6的远程服务器，绕过IPv4，再由服务器代替我们访问外网，再把得到的数据传回来就可以了。虚拟专用网络等方式可以将所有流量加密，通过IPv6传输给远程服务器，这并不影响IPv4资源的访问。只是校内资源，比如抢课，需要把它关掉。

中国大陆并没有适合的双栈（IPv6+IPv4）VPS提供商，再加上不能明说的原因，我选择了Vultr的西雅图服务器。5美元一个月的主机，可以提供一个IPv4、一个IPv6（需要自己勾选），配置也够用，1000G的流量近乎于无限。

将SSR客户端配置好，把电脑连上之后，似乎没有什么问题。在之后的宋浩测试（指看了一天宋浩）之中，发现观看1080p哔哩哔哩视频没有任何压力，同时校园网一天只计了20M流量，可能是iPad偷跑的（手机关闭WiFi）。

这个结果无疑是很令人惊喜的，但是之后我遇到了一些问题。

三

电脑上的测试成功了，但是其他设备上的测试都遇到了些问题：连不上IPv6的SSR。

后来发现，我的两台Android手机（小米10 Pro和运行Pixel Experience的小米5s）全都无法获取校园网IPv6地址，而iPad则更难搞——国区搞不到SSR客户端。

我的流量需求，电脑当然占大头，但是手机和iPad需求量也很大。不看视频，手机一天能够使用300M左右；而iPad开启了GoodNotes的iCloud与OneDrive同步，一天下来最多可以消耗掉2-3G流量。当然，大部分是上行，这个问题不大。

也请求舍友使用 https://test-ipv6.com 测试IPv6获取情况，发现有一位舍友的手机获取到了IPv6，而所有人都只有一台设备能获取。由此排除了DHCPv6不受Android设备支持的原因。

四

为了让所有设备都能免流校园网，我在考虑使用一个路由（或者类似路由的东西），广播一个全局经过IPv6的网络。我考虑过用备用机当热点，手机接收校园网WiFi信号，全局开SSR，然后将这个隧道经由热点分享出去。手机功耗够低，不太引人注目，而且性能够强。但是缺点也很明显：不够稳定，设备一多就不太好。

于是我买了一台小米AC2100路由器，通过有线连接学校网络。AC2100是小米路由器的口碑翻身之作，5GHz信号覆盖据说非常不错，也有大量的第三方固件，而第三方固件可以支持安装SSR等插件。同价位也有小米AC2350，性能更强，但是第三方固件少；而价位更低的红米AC2100（套娃机）和腾达AC9，则主要因为外观的原因没有被我选中。

我选择使用Padavan（也被称为老毛子）固件 [1]。不得不说，万能的恩山无线论坛真是什么关于路由器的玩意都有……

刷入固件之后，能够很明显地感觉到信号好了非常多，即使在厕所也不会断连了。（笑）而在桌前，甚至可以达到 -30dbm。

五

我将路由器连入学校的网口，却发现网口并没有提供校园网拨号宽带，除非办理运营商的宽带业务。

正当我一筹莫展之时，我发现了Padavan固件设置中有一个 “无线桥接”，可以接收其他WiFi信号并作为WAN，然后经过路由器再发射出去。

将2.4GHz和5GHz全部设为桥接之后，连接SSR，就可以直接访问Google等外网了。但是即使能够设置全局通过IPv6的SSR访问网络，通过测速等一系列手段（IPv4限速约10Mbps，IPv6无限速），还是发现有一部分流量无法通过IPv6，而是通过校园网的v4访问的。

也就是说，这个时候只能把它当作全局访问外网的一个工具。

六

当我将电脑、手机、iPad接入路由器的时候，发现了同样的问题：电脑可以访问IPv6，而手机只有v4连接。兜兜转转，又回到了最开始的情况。

排查一下情况，发现在使用IPv4的SSR节点。当我切换到IPv6的SSR节点时，打开任何页面都遭到了Connection Reset。不得已只能切换回IPv4节点，而且电脑也无法访问国内网站。难道是GFW List的问题？或者，既然电脑是唯一一个能够访问IPv6的设备，会不会是v6和v4代理的问题……？

七

打开路由器的外网状态页面，发现外网IPv6地址根本无法获取。一番搜索之后发现了借由 NAPT66 获取内网与外网IPv6的方法 [2]。它是一个由北邮大佬开发的在IPv6环境下使用NAT的工具。在高级设置 - 外部网络 - IPv6设置中，这样设置各选项。

其中，DNSv6服务器可以自己选择，一些公共的DNSv6服务器可以在这里找到。

注意 “获取IPv6外网地址” 一定要选“从两端”，否则不能获取到外网地址！[3]

然后到高级设置 - 系统管理 - 服务，打开 “启用NAPT66” 然后重启路由器，应该就可以获取到IPv6地址了。

这里可以用 test-ipv6.com 获取IPv6连接情况。如果你已经连上IPv6互联网，那么

电脑当然也没有问题了。

期间我的服务器IPv6地址突然ping不通了，然后等了半天多又好了，真的是玄学……

八

剩下的当然就是在路由器开启全局SSR了。请注意：如果你使用SS或者V2ray，那么可能需要一些配置才能用IPv6连接；SSR则原生支持IPv6。

导入SSR之后，记得手动切换成SSR协议，然后检查一下协议插件和混淆插件。Padavan的SSR设置似乎有点反人类。

不过似乎连接之后，仍会产生IPv4下载流量，可以在 “系统管理” 的“控制台”中执行 iptables -P INPUT DROP 如下命令

来禁用IPv4下载。或者你也可以在系统管理 - 服务开启SSH，使用SSH客户端执行命令。

即使有一点点v4上传流量也没关系，毕竟不收费。理论上，所有流量都应该走v6了。

到此，主要内容就基本完成了。只要是透过路由器连接的网络，都可以免流；而对于宿舍之外，无法自行部署路由器的地方，建议搭配大流量手机卡使用。或者也可以用校园网——如果你用流量不是很多的话。如果连着校园网时能通过上述的那个网站查询到你的IPv6地址，那么开一个全局SSR也是不错的选择。我的iPad则是一直连着校园网，因为绝大部分的流量是笔记备份（上传流量），所以无需担心流量问题。

未来如果IPv6全面普及，也许就不需要再通过SSR了，只需要那句iptables命令就可以了……SSR的作用，只是保证IPv4 only的网站正常访问。

九

有时候会遇到路由器无法获取到IPv6地址的情况。这时在前面给路由器刷入的Breed就有用处了：重启进Breed恢复控制台，修改设备的MAC地址（最好都改改），一般能够重新获取到IPv6。

可以使用 MAC 地址生成器生成地址，还可以使用 MAC 地址查找来获取到特定制造商的地址前缀（如果在IEEE注册了，而且存在于网站的数据库中），比如Apple的前缀之一是0010FA，神舟电脑ODM蓝天的前缀是0090F5。

也可以使用我写的 MAC 地址生成器直接生成一批不同的MAC地址。

现存问题

现在SSR仍然会有间歇的断开现象，而且一断就很久连不上。但就如同我的离散数学老师说的，“计算机不存在玄学问题”，我只能说不知道为什么了……

初期也出现过一开全局就特别慢的现象，还以为是路由器性能不足，后来速度突然提升，也不知道这个是为啥。

参考文献

红米 (小米)AC2100 无需 Telnet 刷入 Breed 和 Padavan 固件教程 - 恩山无线论坛
校园网路由器后设备使用 ipv6 经验分享 - 知乎
h 大老毛子 ipv6 的 wan 口地址获取不到 - 恩山无线论坛