NortH开发团队提高知识测试题（NO.1)

NortH开发团队提高知识测试题（NO.1)

在考试过程中，请遵守：
①请勿以除自己思考外的任何形式获取答案，违反者将取消考试资格。
②可以在不违反第一条的情况下，使用计算机、计算器等电子设备。
本试题满分300分，选择题共90分，简答题共50分，程序写作题共160分。
请认真作答！

---

一、客观题（每小题有一个或多个选项符合题目要求，多选题会在题号后注明，共90分，单项选择题回答正确得全部分数，多项选择题回答完全正确得全部分数，部分答对得半分数，答错不得分）

（一）数学（共15分）

1. 计算1+2+3+4+…+114514 （1.5分）
   A. 6,556,670,841
   B. 6,556,670,840
   C. 6,556,670,842
   D. 6,556,670,843

2. 计算114515+114516+114517+…+1919810 （1.5分）
   A. 1,436,277,586,305
   B. 1,836,227,586,314
   C. 1,836,277,586,314
   D. 1,836,277,587,304

3. C城市的车牌号由五位数字0-9组成，将车牌号倒置显示的数字和原来相同的称作回文车牌。如0倒过来是0，1倒过来是1，2倒过来是5，5倒过来是2，6倒过来是9，8倒过来是8，9倒过来是6，其他数字倒过来不构成数字，问共有多少个回文车牌？（3分）
   A. 147
   B. 153
   C. 75
   D. 182

4. 共有12颗相同的糖果，分配给10个各不相同的小芃芃，共有多少种分法？（3分）
   A. 55
   B. 44
   C. 66
   D. 88

5. 设数列 { a n } \{a_n\} {an​} 满足 $a_1=1,a_{n+1}=\frac{1}{1+a_n}$ ，记 $b_n=\frac{1}{a_n+\frac{1+\sqrt{5}}{2}}$ ，数列 { b n } \{b_n\} {bn​} 的前 $n$ 项和为 $S_n$ 。求 $\underset{n\to \infty }{\lim }{S}_n$ 的值。（6分）
   A. 不存在
   B. 1
   C. 0
   D. -1

计算机基础知识、编程语言掌握能力（共75分）

6. 判断对错：计算机病毒只会通过网络传播，只要计算机不联网就绝对不会感染病毒。（1.5分）
   A. 对
   B. 错

7. 判断对错：在采用分页存储管理的系统中，逻辑地址的结构是固定的，由页号和页内偏移两部分组成，且页内偏移的位数决定了页面的大小，而页号的位数决定了逻辑地址空间中页面的总数。所以，若某系统逻辑地址为 32 位，其中页号占 10 位，页内偏移占 22 位，那么该系统的页面大小为 $2^{22}$ 字节，逻辑地址空间最多可容纳 $2^{10}$ 个页面。（1.5分）
   A. 对
   B. 错

8. 判断对错误：在一个基于 TCP/IP 协议的网络环境中，主机 A 向主机 B 发送一个大文件，采用了 MSS（最大段大小）为 1460 字节的 TCP 报文段。假设网络层使用 IPv4 协议，没有选项字段，且 IP 分组在传输过程中需要经过一个 MTU（最大传输单元）为 1500 字节的网络链路。由于 IP 头部长度为 20 字节，TCP 头部长度为 20 字节，因此每个 IP 分组恰好能承载一个 TCP 报文段的数据，不会发生 IP 分片。（1.5分）
   A. 对
   B. 错

9. 判断对错：在分布式数据库系统中，使用两阶段提交协议（2PC）进行事务处理时，若协调者在准备阶段收到所有参与者的 “同意” 消息，那么在提交阶段，即使部分参与者因为网络故障暂时失联，协调者依然可以安全地向所有可达的参与者发送提交指令，因为最终所有失联的参与者恢复连接后，通过日志重放机制必然能使数据库状态达成一致，不会出现数据不一致问题。（1.5分）
   A. 对
   B. 错

10. 在操作系统中，若采用分页式存储管理，某进程的页表如下所示。已知页面大小为 4KB，逻辑地址为 0x12345（十六进制），则对应的物理地址是（ ）。（3分）

页号	物理块号
0	2
1	3
2	5
3	7

A. 0x22345
B. 0x32345
C. 0x52345
D. 0x72345

11. 在一个采用 CSMA/CD 协议的网络中，传输介质是一根长度为 1000m 的完整电缆，信号传播速度为 2×10⁸m/s，数据传输速率为 100Mbps。若某站点在发送数据时检测到冲突，并且在发送数据的第 25.6μs 时停止发送，那么该站点发现冲突时已发送的数据量是（ ）。（3分）
    A. 256bit
    B. 512bit
    C. 128bit
    D. 384bit

12. 在一个具有五级流水线的处理器中，分别是取指（IF）、译码 / 读寄存器（ID）、执行（EX）、访存（MEM）、写回（WB）。假设指令执行过程中，不存在数据转发，且前一条指令的结果在 WB 阶段才能被后续指令使用。现有如下指令序列：

I1: ADD R1, R2, R3 ; R1 = R2 + R3
I2: SUB R4, R1, R5 ; R4 = R1 - R5
I3: MUL R6, R4, R7 ; R6 = R4 * R7

在理想情况下，不考虑其他延迟，完成这三条指令需要多少个时钟周期？（3分）
A. 7
B. 8
C. 9
D. 10

13. 在一个基于向量处理器的高性能计算系统中，向量寄存器长度为 64，每个向量元素为双精度浮点数（8 字节）。向量加法指令执行时，每个时钟周期可以处理 4 个向量元素。假设系统的主存带宽为 128GB/s，向量加载（load）指令从主存读取数据到向量寄存器，向量存储（store）指令将向量寄存器的数据写回主存。向量运算指令（如加法、乘法等）在向量寄存器之间进行操作，且不考虑向量运算指令执行过程中的延迟。现有一个计算任务，需要对两个长度为 1024 的向量进行加法运算，并将结果存储回主存。若向量加载和存储指令都以向量寄存器长度为单位进行数据传输，且忽略指令执行的其他开销，仅考虑数据传输带宽限制，完成该任务所需的最短时间约为（ ）。（3分）
    A. 128μs
    B. 192μs
    C. 256μs
    D. 384μs

14. 在一个高度优化的多核处理器系统中，为满足高性能计算需求，对缓存一致性协议与内存层次结构进行了深度定制。系统拥有四级缓存（L1 - L4），各级缓存关联度与容量设置如下：L1 缓存为 8 路组相联，每核容量 64KB；L2 缓存为 16 路组相联，每核容量 256KB；L3 缓存为 32 路组相联，共享容量 4MB；L4 缓存为 64 路组相联，共享容量 16MB。内存采用 DDR5 - 6400 规格，带宽为 51.2GB/s。处理器核心采用乱序执行架构，支持同时多线程（SMT）技术，每个核心可同时处理 4 个线程。假设在某一时刻，系统中有多个线程并发执行复杂的科学计算任务，这些任务涉及大量的矩阵运算与数据访存操作。在这种情况下，以下关于该系统的性能分析，正确的是（ ）。（3分）
    A. 由于 L1 缓存容量相对较小，在矩阵运算中频繁的访存操作会导致 L1 缓存命中率极低，进而使得处理器核心大部分时间处于等待数据从内存传输的状态，严重影响系统性能。尽管 L1 缓存采用 8 路组相联提高了空间利用率，但对于大数据量的矩阵运算，容量瓶颈问题无法通过关联度改善。
    B. 尽管 L3 缓存为共享缓存且容量较大，但由于其 32 路组相联的方式在处理大量并发线程的访存请求时，可能会出现严重的缓存冲突，导致缓存命中率不升反降。相比之下，若采用直接映射缓存，虽然可能增加冲突的概率，但可以减少缓存标记位的开销，从而在整体上提高系统性能。
    C. 内存采用 DDR5 - 6400 规格，虽带宽为 51.2GB/s，但在多线程并发执行矩阵运算时，由于内存访问的局部性原理，实际可用带宽远低于理论值。因为不同线程可能频繁访问不同区域的数据，使得内存控制器难以进行有效的数据预取和调度，进而影响系统整体性能。
    D. 处理器核心采用乱序执行架构与 SMT 技术，虽能在一定程度上提高指令级并行度与线程级并行度，但在处理矩阵运算这类对数据依赖关系要求较高的任务时，乱序执行可能会导致频繁的指令重排序，增加处理器的控制复杂度。同时，SMT 技术可能会因为多个线程共享资源而产生资源竞争，最终导致系统性能提升有限。

15. 在 Python 语言中，以下代码的输出结果是（ ）：（3分）

a = [1, 2, 3]
b = a
a.append(4)
print(b)

A. [1, 2, 3]
B. [1, 2, 3, 4]
C. [1, 2, 3, 4, 4]
D. 报错

16. 以下是一段 Python 代码：

class A:
    def __init__(self):
        self.val = 0
        self.lst = []

    def add(self, value):
        def helper():
            self.val += value
            self.lst.append(value)
        return helper


a = A()
func1 = a.add(1)
func2 = a.add(2)
func1()
func2()
print(a.val, a.lst)

该代码的输出结果是（）。（3分）
A. (0, [])
B. (3, [1, 2])
C. (1, [1])
D. (2, [2])

17. 考虑以下 C++ 代码片段，该代码使用二分查找算法在一个已排序的整数数组中查找元素：

#include <iostream>
#include <vector>

int binarySearch(const std::vector<int>& arr, int target) {
    int left = 0;
    int right = arr.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int main() {
    std::vector<int> arr = {1, 3, 5, 7, 9, 11, 13, 15};
    int target = 7;
    int result = binarySearch(arr, target);
    std::cout << "The index of the target is: " << result << std::endl;
    return 0;
}

假设我们要在上述代码中添加对数组元素为负数的处理，如果数组元素可能包含负数，以下哪种修改是正确的（ ）。（3分）
A. 在 binarySearch 函数内部添加一个 if 语句，如果 arr[mid] ＜ 0，则返回 -1。
B. 在 main 函数中，添加一个循环遍历 arr，如果元素为负，则将其从 arr 中移除，再调用 binarySearch。
C. 在 binarySearch 函数内部添加一个 if 语句，如果 arr[mid] ＜ 0，将 left 或 right 的范围进行调整，以排除负数元素。
D. 二分查找算法不能处理包含负数的数组，需要使用其他搜索算法。

18. 考虑以下 C++ 代码，该代码尝试使用快速排序算法对数组进行排序：

#include <iostream>
#include <vector>

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}

void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6};
    int n = arr.size();
    quickSort(arr, 0, n - 1);
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }
    return 0;
}

假设我们要对这段代码进行优化，以下哪个优化方法是不恰当的（ ）：（3分）
A. 在 partition 函数中，使用随机化选择枢轴元素，而不是总是选择最后一个元素作为枢轴元素。
B. 在 quickSort 函数中，当子数组的元素数量小于一定阈值时，使用插入排序代替快速排序。
C. 在 quickSort 函数中，将递归调用改为迭代调用，使用栈来存储子数组的范围。
D. 在 swap 函数中，使用异或运算 a ^= b; b ^= a; a ^= b; 来交换元素，以提高性能。

19. 考虑以下 C++ 代码，该代码尝试实现一个基于堆的数据结构并进行堆排序：

#include <iostream>
#include <vector>

void heapify(std::vector<int>& arr, int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest!= i) {
        std::swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(std::vector<int>& arr) {
    int n = arr.size();

    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i > 0; i--) {
        std::swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

void printArray(const std::vector<int>& arr) {
    for (int i = 0; i < arr.size(); ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6, 7};
    heapSort(arr);
    printArray(arr);
    return 0;
}

假设我们需要在堆排序的基础上，实现一个新的功能：对于一个已排序的数组，找出其中第k大的元素，以下哪个方法是最不高效的（ ）：（3分）
A. 对数组进行堆排序，然后从后往前数第 k 个元素。
B. 使用快速选择算法，其平均时间复杂度为 O(n) 。
C. 修改堆排序算法，在堆化过程中，当堆的大小达到 k 时停止，然后返回堆顶元素。
D. 先将数组的前 k 个元素构建一个最小堆，然后遍历数组中剩余元素，若元素比堆顶大，则替换堆顶元素并重新堆化，最终堆顶元素就是第 k 大元素。

20. 考虑以下HTML代码，回答问题：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Complex Web App</title>
    <style>
        #container {
            display: flex;
            flex-wrap: wrap;
            justify-content: space-around;
        }
      .item {
            width: 100px;
            height: 100px;
            background-color: red;
            margin: 10px;
            transition: all 0.5s ease-in-out;
        }
      .item:hover {
            transform: scale(1.2);
        }
    </style>
</head>
<body>
    <div id="container">
        <div class="item" data-id="1"></div>
        <div class="item" data-id="2"></div>
        <div class="item" data-id="3"></div>
    </div>
    <script>
        document.addEventListener("DOMContentLoaded", function() {
            let items = document.querySelectorAll(".item");
            items.forEach(function(item) {
                item.addEventListener("click", function() {
                    let id = this.getAttribute("data-id");
                    let xhr = new XMLHttpRequest();
                    xhr.open("GET", `/api/item/${id}`, true);
                    xhr.onreadystatechange = function() {
                        if (xhr.readyState === 4 && xhr.status === 200) {
                            let response = JSON.parse(xhr.responseText);
                            if (response.success) {
                                item.style.backgroundColor = response.color;
                                let newItem = document.createElement("div");
                                newItem.className = "item";
                                newItem.setAttribute("data-id", response.newId);
                                newItem.addEventListener("click", function() {
                                    this.remove();
                                });
                                document.getElementById("container").appendChild(newItem);
                            } else {
                                console.error("Failed to fetch item data");
                            }
                        }
                    };
                    xhr.send();
                });
            });
        });
    </script>
</body>
</html>

对于上述代码，以下说法错误的是（ ）：（3分）
A. 当鼠标悬停在 .item 类的元素上时，元素会在 0.5 秒内缩放至原始大小的 1.2 倍。
B. 点击 .item 类的元素时，会向 /api/item/${id} 发送一个 GET 请求，其中 id 是元素的 data-id 属性的值。
C. 如果 GET 请求成功且响应的 success 属性为 true，会将点击元素的背景色更改为响应中的 color 属性的值，并添加一个新的 .item 元素。
D. 当添加新的 .item 元素时，新元素的 data-id 属性会自动递增，无需从响应中获取。

21. 考虑以下 MySQL 数据库表结构和 SQL 查询语句：

CREATE TABLE orders (
    order_id INT PRIMARY KEY AUTO_INCREMENT,
    customer_id INT,
    order_date DATE,
    total_amount DECIMAL(10, 2),
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

CREATE TABLE customers (
    customer_id INT PRIMARY KEY AUTO_INCREMENT,
    customer_name VARCHAR(100),
    customer_email VARCHAR(100)
);

SELECT c.customer_name, o.order_date, o.total_amount
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
WHERE o.order_date BETWEEN '2023-01-01' AND '2023-12-31'
ORDER BY o.total_amount DESC
LIMIT 10;

对于上述 SQL 语句，以下哪种优化策略是最有效的（假设数据量非常大）？（3分）
A. 在 orders 表的 order_date 列上创建一个普通索引
B. 在 customers 表的 customer_id 列上创建一个普通索引。
C. 在 orders 表的 (order_date, total_amount) 列上创建一个复合索引。
D. 在 orders 表的 (customer_id, order_date, total_amount) 列上创建一个复合索引。

22. 考虑以下 Markdown 内容和 JSON 数据：
    Markdown 内容：

# 标题 1
这是一段 **加粗** 的文本，包含一个 [链接](https://example.com)。

- 列表项 1
- 列表项 2

| 表头 1 | 表头 2 |
| ------ | ------ |
| 数据 1 | 数据 2 |

JSON 数据：

{
  "title": "标题 1",
  "content": [
    "这是一段 **加粗** 的文本，包含一个 [链接](https://example.com)。",
    "- 列表项 1",
    "- 列表项 2",
    "| 表头 1 | 表头 2 |",
    "| ------ | ------ |",
    "| 数据 1 | 数据 2 |"
  ]
}

以下是一个将 Markdown 转换为 JSON 的 JavaScript 函数：

function markdownToJson(markdown) {
  let lines = markdown.split("\n");
  let result = {
    title: "",
    content: []
  };
  let inTable = false;
  let tableData = [];
  for (let line of lines) {
    if (line.startsWith("# ")) {
      result.title = line.slice(2);
    } else if (line.startsWith("- ")) {
      result.content.push(line);
    } else if (line.startsWith("|")) {
      if (!inTable) {
        inTable = true;
        tableData.push(line);
      } else {
        tableData.push(line);
        if (line.trim() === "") {
          result.content.push(tableData);
          inTable = false;
          tableData = [];
        }
      }
    } else {
      result.content.push(line);
    }
  }
  if (inTable) {
    result.content.push(tableData);
  }
  return result;
}

对于上述的 Markdown 转 JSON 函数，以下说法错误的是（ ）：（3分）
A. 该函数能够正确处理 Markdown 中的标题、列表和简单文本内容。
B. 该函数在处理表格时，如果表格之间有额外的空行，会将表格拆分成多个部分。
C. 该函数将 Markdown 中的加粗文本和链接保留为原始字符串，未进行特殊处理。
D. 该函数将 Markdown 中的不同类型的元素都存储在 content 属性中，标题存储在 title 属性中。

23. （多选）假设你正在开发一个在线学习平台，该平台具备用户认证、课程展示、学习记录跟踪等功能。以下是关于该平台开发过程中涉及到多种技术的描述，其中正确的有（ ）：（9分）
    A. 在 Python 后端，使用 Flask 框架搭建 Web 服务器，处理用户登录请求时，为防止 SQL 注入攻击，对用户输入的用户名和密码在传入 MySQL 查询语句之前，应使用提供的参数化查询方式，例如：

from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] ='mysql://user:password@localhost/learning_platform'
db = SQLAlchemy(app)

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    user = db.session.execute('SELECT * FROM users WHERE username = :username AND password = :password', 
                            {'username': username, 'password': password}).fetchone()
    if user:
        return 'Login successful'
    return 'Login failed'

B. 前端页面使用 HTML、CSS 和 JavaScript 构建。在课程展示页面，为了实现课程图片的懒加载，提高页面加载性能，可以使用 JavaScript 监听接口，当图片进入视口时再加载图片资源，代码如下：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Course Page</title>
    <style>
      .course-img {
            width: 300px;
            height: 200px;
            background-color: #ccc;
        }
    </style>
</head>

<body>
    <img class="course-img" data-src="course1.jpg" alt="Course 1">
    <img class="course-img" data-src="course2.jpg" alt="Course 2">

    <script>
        const observer = new IntersectionObserver((entries, observer) => {
            entries.forEach(entry => {
                if (entry.isIntersecting) {
                    const img = entry.target;
                    img.src = img.dataset.src;
                    observer.unobserve(img);
                }
            });
        });

        const courseImgs = document.querySelectorAll('.course-img');
        courseImgs.forEach(img => {
            observer.observe(img);
        });
    </script>
</body>

</html>

C. 在 Java 编写的用户学习记录模块中，为保证数据的一致性和事务性，在向 MySQL 数据库插入学习记录时，使用 JDBC 进行操作，并将多个相关操作包裹在一个事务中，示例代码如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class LearningRecordDao {
    private static final String URL = "jdbc:mysql://localhost:3306/learning_platform";
    private static final String USER = "user";
    private static final String PASSWORD = "password";

    public void insertLearningRecord(int userId, int courseId, String progress) {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
            connection.setAutoCommit(false);
            String insertQuery = "INSERT INTO learning_records (user_id, course_id, progress) VALUES (?,?,?)";
            try (PreparedStatement statement = connection.prepareStatement(insertQuery)) {
                statement.setInt(1, userId);
                statement.setInt(2, courseId);
                statement.setString(3, progress);
                statement.executeUpdate();
            }
            connection.commit();
        } catch (SQLException e) {
            if (connection!= null) {
                try {
                    connection.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        }
    }
}

D. 为了提高平台的安全性，在 C++ 编写的某些底层数据处理模块中，对于用户上传的文件，在进行处理之前，需要对文件的类型进行严格校验，防止恶意文件上传。例如，可以通过检查文件头信息来判断文件类型，以防止用户上传可执行文件冒充图片文件，代码如下：

#include <iostream>
#include <fstream>
#include <string>

bool isValidImageFile(const std::string& filePath) {
    std::ifstream file(filePath, std::ios::binary);
    if (!file.is_open()) {
        return false;
    }
    char buffer[4];
    file.read(buffer, 4);
    file.close();
    // 以常见的 JPEG 文件头为例
    if (buffer[0] == 0xFF && buffer[1] == 0xD8 && buffer[2] == 0xFF) {
        return true;
    }
    return false;
}

E. 平台的用户信息以 JSON 格式存储在 MySQL 数据库的表中，其中字段存储 JSON 数据。在 Python 中查询用户信息时，从数据库取出 JSON 数据后，使用模块将其解析为 Python 字典，代码如下：

import json
import mysql.connector

mydb = mysql.connector.connect(
    host="localhost",
    user="user",
    password="password",
    database="learning_platform"
)

mycursor = mydb.cursor()
mycursor.execute("SELECT user_info FROM users WHERE user_id = 1")
result = mycursor.fetchone()
if result:
    json_data = result[0]
    user_dict = json.loads(json_data)
    print(user_dict)

F. 在前端 JavaScript 代码中，为了实现用户密码的加密传输，使用模块中的函数对用户输入的密码进行多次哈希运算，增加密码的安全性，代码如下：

const crypto = require('crypto');

function hashPassword(password) {
    return crypto.pbkdf2Sync(password, 'random_salt', 10000, 64, 'sha512').toString('hex');
}

const userPassword = 'user_input_password';
const hashedPassword = hashPassword(userPassword);
console.log(hashedPassword);

G. 项目文档使用 Markdown 编写，为了清晰展示数据库表结构，使用 Markdown 的表格语法来描述表，如下：

| 列名 | 数据类型 | 描述 |
| ---- | ---- | ---- |
| course_id | int | 课程唯一标识，自增长主键 |
| course_name | varchar(255) | 课程名称 |
| instructor | varchar(100) | 授课教师 |
| price | decimal(10, 2) | 课程价格 |

H. 在 Java 代码中，为了防止 XSS（跨站脚本攻击），对用户输入的评论内容进行过滤处理，使用正则表达式去除所有 HTML 标签，代码如下：

import java.util.regex.Pattern;

public class XSSFilter {
    private static final Pattern HTML_TAG_PATTERN = Pattern.compile("<.*?>");

    public static String filter(String input) {
        return HTML_TAG_PATTERN.matcher(input).replaceAll("");
    }
}

24. （多选）假设你正在处理一个复杂的计算几何问题，需要在 Python 中实现相关算法。给定一个平面上的点集 $S$ ，其中包含 $n$ 个点，每个点的坐标为 $(x,y)$ ，并且这些点存储在一个列表 points 中，每个元素是一个包含两个浮点数的元组，例如 [(x1, y1), (x2, y2), …, (xn, yn)]。
    现在要解决以下几个子问题：
    寻找最近点对：使用分治法实现寻找点集中距离最近的两个点对，要求在最坏情况下时间复杂度为 $O(n\log n)$ 。
    凸包问题：实现 Graham 扫描算法来计算点集的凸包，凸包上的点按逆时针顺序返回。
    点集三角剖分：使用 Delaunay 三角剖分算法将点集进行三角剖分，并且要保证三角剖分的结果满足空圆性质（即每个三角形的外接圆内不包含其他点）。以下关于这些算法实现的描述，正确的是（ ）：（9分）
    A. 在实现最近点对的分治法中，将点集按 x 坐标排序后，通过递归地将点集分成左右两部分，分别计算左右两部分的最近点对距离 d1 和 d2，然后考虑跨越中线的点对距离 d3。在计算 d3 时，对于中线附近的点，按 y 坐标排序后，只需检查距离中线左右距离小于 $\min (d1,d2)$ 的点，这样可以保证在 $O(n)$ 时间内完成对跨越中线点对距离的计算，从而整体时间复杂度为 $O(n\log n)$。示例代码如下：

import math


def distance(p1, p2):
    return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)


def closest_pair(points):
    points.sort(key=lambda p: p[0])

    def divide_and_conquer(points):
        n = len(points)
        if n <= 3:
            min_dist = float('inf')
            for i in range(n):
                for j in range(i + 1, n):
                    dist = distance(points[i], points[j])
                    if dist < min_dist:
                        min_dist = dist
            return min_dist
        mid = n // 2
        mid_x = points[mid][0]
        d1 = divide_and_conquer(points[:mid])
        d2 = divide_and_conquer(points[mid:])
        d = min(d1, d2)
        strip = [p for p in points if mid_x - d <= p[0] <= mid_x + d]
        strip.sort(key=lambda p: p[1])
        for i in range(len(strip)):
            for j in range(i + 1, min(i + 7, len(strip))):
                dist = distance(strip[i], strip[j])
                if dist < d:
                    d = dist
        return d

    return divide_and_conquer(points)

B. 在 Graham 扫描算法实现凸包时，首先需要找到 y 坐标最小的点 p0，将其与点集中的第一个点交换位置。然后按照极角从小到大对其余点进行排序（极角相同的点按距离 p0 从近到远排序）。在扫描过程中，使用一个栈来维护凸包上的点，每次加入新点时，检查栈顶的两个点与新点构成的向量是否为顺时针方向，如果是，则弹出栈顶元素。示例代码如下：

def orientation(p, q, r):
    val = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
    if val == 0:
        return 0
    elif val > 0:
        return 1
    else:
        return 2


def distance_squared(p, q):
    return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2


def graham_scan(points):
    ymin = min(points, key=lambda p: p[1])
    points.remove(ymin)
    points.sort(key=lambda p: (math.atan2(p[1] - ymin[1], p[0] - ymin[0]), distance_squared(p, ymin)))
    points = [ymin] + points
    stack = [points[0], points[1]]
    for i in range(2, len(points)):
        while len(stack) > 1 and orientation(stack[-2], stack[-1], points[i]) == 2:
            stack.pop()
        stack.append(points[i])
    return stack

C. 在实现 Delaunay 三角剖分算法时，可以先构造一个包含所有点的超级三角形（这个超级三角形足够大，能包含所有实际的点），然后从点集中逐个加入点。对于每个新加入的点，找到包含该点的三角形，然后将该三角形的三条边向新点进行三角剖分，同时检查并修复可能出现的不满足空圆性质的情况。在检查空圆性质时，可以通过计算三角形外接圆的圆心和半径，然后判断其他点是否在圆内。示例代码如下（仅为关键部分示意）：

import math


def circumcenter(a, b, c):
    x1, y1 = a
    x2, y2 = b
    x3, y3 = c
    d = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2))
    ux = ((x1 * x1 + y1 * y1) * (y2 - y3) + (x2 * x2 + y2 * y2) * (y3 - y1) + (x3 * x3 + y3 * y3) * (y1 - y2)) / d
    uy = ((x1 * x1 + y1 * y1) * (x3 - x2) + (x2 * x2 + y2 * y2) * (x1 - x3) + (x3 * x3 + y3 * y3) * (x2 - x1)) / d
    return ux, uy


def circumradius(a, b, c):
    ux, uy = circumcenter(a, b, c)
    return math.sqrt((a[0] - ux) ** 2 + (a[1] - uy) ** 2)


def in_circle(a, b, c, p):
    ux, uy = circumcenter(a, b, c)
    radius = circumradius(a, b, c)
    return (p[0] - ux) ** 2 + (p[1] - uy) ** 2 <= radius ** 2


def delaunay_triangulation(points):
    super_triangle = [(1e10, 1e10), (-1e10, 1e10), (0, -1e10)]
    triangles = [super_triangle]
    for point in points:
        containing_triangle = None
        for triangle in triangles:
            if is_point_inside_triangle(point, triangle):
                containing_triangle = triangle
                break
        new_triangles = split_triangle(containing_triangle, point)
        triangles.remove(containing_triangle)
        triangles.extend(new_triangles)
        for triangle in triangles:
            for other_point in points:
                if other_point not in triangle and in_circle(*triangle, other_point):
                    flip_edge(triangle, other_point)
    result = []
    for triangle in triangles:
        if not any(p in super_triangle for p in triangle):
            result.append(triangle)
    return result

D. 在最近点对算法中，如果不先将点集按 x 坐标排序，直接随机地将点集分成两部分，也能保证在 (O(n \log n)) 的时间复杂度内找到最近点对，因为分治法的核心是递归地分解问题，与点集的初始顺序无关。
E. 在 Graham 扫描算法中，极角排序可以使用叉积来判断点的相对位置关系，从而确定极角的大小顺序。叉积的计算公式为 $(q_y-p_y)\ast (r_x-q_x)-(q_x-p_x)\ast (r_y-q_y)$，如果结果为正，则点 r 在向量 $\overrightarrow{pq}$ 的顺时针方向；如果结果为负，则点 r 在向量 $\overrightarrow{pq}$) 的逆时针方向；如果结果为 0，则三点共线。
F. 在 Delaunay 三角剖分中，当进行边翻转操作修复不满足空圆性质的情况时，边翻转的原则是要保证翻转后的三角剖分仍然满足 Delaunay 三角剖分的定义，即所有三角形的外接圆内不包含其他点。边翻转操作可以通过交换两个相邻三角形的公共边来实现。
G. 在最近点对算法的实现中，对于跨越中线的点对距离计算，按 y 坐标排序后，理论上最多只需要检查每个点与它后面的 7 个点的距离，这是基于分治法的性质以及平面上点的分布特点得出的结论，这样可以保证在 $O(n)$ 的时间复杂度内完成这部分计算。
H. 在 Graham 扫描算法实现凸包时，最后栈中存储的点就是按逆时针顺序排列的凸包上的点，无需再进行额外的排序操作。

25. （多选）考虑一个带权有向图 $G=(V,E)$，其中 V 是顶点集，E 是边集，每条边 $e=(u,v)$ 都有一个非负权值 $w(e)$。现在要解决一系列与该图相关的复杂问题：
    最小费用流问题：假设图中存在源点 s 和汇点 t，每条边除了权值 w 外，还有一个容量 c。我们要找到一个从 s 到 t 的流 f，使得在满足流量守恒和容量限制的前提下，流的总费用 ${\sum }_{e\in E}w(e)\cdot f(e)$ 最小。
    强连通分量分解：将图 G 分解为若干个强连通分量$SC{C}_1,SC{C}_2,\cdots ,SC{C}_k$，使得每个 $SC{C}_i$ 内部的任意两个顶点之间都存在路径。哈密顿路径问题：判断图 G 中是否存在一条路径，该路径恰好经过每个顶点一次。以下关于这些问题的算法描述，正确的是（ ）：（9分）
    A. 对于最小费用流问题，可以使用连续最短路算法（Successive Shortest Path Algorithm）来求解。该算法从初始零流开始，每次在残留网络中找到一条从源点到汇点的最短路径（这里的路径长度是根据边的费用 w 计算），并沿着这条路径增加流，直到无法再找到从源点到汇点的路径为止。在实现过程中，为了找到最短路径，可以使用 Dijkstra 算法，但需要注意处理负权边的情况。如果图中存在负权边，可先使用 Bellman - Ford 算法预处理，将其转化为等价的非负权图后再使用 Dijkstra 算法。示例代码如下（Python 代码）：

import math
from collections import defaultdict


def bellman_ford(graph, s):
    dist = defaultdict(lambda: math.inf)
    dist[s] = 0
    for _ in range(len(graph) - 1):
        for u in graph:
            for v, w in graph[u].items():
                if dist[u]!= math.inf and dist[u] + w < dist[v]:
                    dist[v] = dist[u] + w
    for u in graph:
        for v, w in graph[u].items():
            if dist[u]!= math.inf and dist[u] + w < dist[v]:
                raise ValueError("Graph contains a negative - weight cycle")
    return dist


def dijkstra(graph, s):
    dist = defaultdict(lambda: math.inf)
    dist[s] = 0
    pq = [(0, s)]
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        for v, w in graph[u].items():
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                heapq.heappush(pq, (dist[v], v))
    return dist


def successive_shortest_path(graph, s, t, capacity):
    flow = 0
    total_cost = 0
    residual_graph = defaultdict(dict)
    for u in graph:
        for v, w in graph[u].items():
            residual_graph[u][v] = w
            residual_graph[v][u] = 0
    while True:
        try:
            dist = bellman_ford(residual_graph, s)
            path = []
            current = t
            while current!= s:
                for u, w in residual_graph.items():
                    if current in w and dist[u] + w[current] == dist[current]:
                        path.append((u, current))
                        current = u
                        break
            path.reverse()
            bottleneck = math.inf
            for u, v in path:
                bottleneck = min(bottleneck, capacity[(u, v)])
            for u, v in path:
                flow += bottleneck
                total_cost += bottleneck * residual_graph[u][v]
                if v in residual_graph[u]:
                    residual_graph[u][v] -= bottleneck
                    if residual_graph[u][v] == 0:
                        del residual_graph[u][v]
                if u in residual_graph[v]:
                    residual_graph[v][u] += bottleneck
        except ValueError:
            break
    return flow, total_cost

B. 在强连通分量分解中，使用 Kosaraju 算法。该算法首先对图 G 进行深度优先搜索（DFS），记录每个顶点的完成时间（即该顶点所有邻接顶点都被访问完后，该顶点的访问结束时间）。然后，将图 G 的所有边反向得到反向图 $G^T$。接着，按照完成时间从大到小的顺序对 $G^T$ 再次进行 DFS，每一次新的 DFS 遍历得到的顶点集就是一个强连通分量。该算法的时间复杂度为 $O(|V|+|E|)$，因为两次 DFS 遍历的时间复杂度均为 $O(|V|+|E|)$。示例代码如下（Python 代码）：

def dfs(graph, u, visited, stack):
    visited[u] = True
    for v in graph[u]:
        if not visited[v]:
            dfs(graph, v, visited, stack)
    stack.append(u)


def dfs_reverse(graph, u, visited, scc):
    visited[u] = True
    scc.append(u)
    for v in graph[u]:
        if not visited[v]:
            dfs_reverse(graph, v, visited, scc)


def kosaraju(graph):
    visited = {u: False for u in graph}
    stack = []
    for u in graph:
        if not visited[u]:
            dfs(graph, u, visited, stack)
    graph_transpose = defaultdict(list)
    for u in graph:
        for v in graph[u]:
            graph_transpose[v].append(u)
    visited = {u: False for u in graph}
    sccs = []
    while stack:
        u = stack.pop()
        if not visited[u]:
            scc = []
            dfs_reverse(graph_transpose, u, visited, scc)
            sccs.append(scc)
    return sccs

C. 对于哈密顿路径问题，由于它是一个 NP - 完全问题，不存在多项式时间的确定性算法。然而，可以使用回溯算法来进行求解。回溯算法从一个初始顶点开始，尝试扩展路径，每次选择一个未访问过的邻接顶点加入路径。如果在某个时刻无法继续扩展路径，则回溯到上一个顶点，尝试其他选择。为了减少搜索空间，可以使用一些剪枝策略，例如，在选择下一个顶点时，优先选择度数较小的顶点，因为度数小的顶点在后续扩展中更容易导致路径失败，从而更早地进行回溯。示例代码如下（Python 代码）：

def hamiltonian_path(graph):
    num_vertices = len(graph)
    path = [-1] * num_vertices
    visited = {u: False for u in graph}

    def backtrack(v, pos):
        visited[v] = True
        path[pos] = v
        if pos == num_vertices - 1:
            return True
        for u in graph[v]:
            if not visited[u]:
                if backtrack(u, pos + 1):
                    return True
        visited[v] = False
        return False

    for start in graph:
        if backtrack(start, 0):
            return path
    return None

D. 在最小费用流问题中，如果使用 Ford - Fulkerson 算法的简单变体来求解，不考虑边的费用 w，只关注流量，最终也能得到最小费用流的结果。因为 Ford - Fulkerson 算法通过不断寻找增广路径来增加流量，而在每次寻找增广路径的过程中，即使不考虑费用，只要路径选择是随机的，最终也会遍历到所有可能的路径组合，从而找到最小费用流。
E. 对于强连通分量分解，Tarjan 算法也是一种常用的方法。该算法在深度优先搜索的过程中，为每个顶点 u 维护两个值：$dfn[u]$ 表示顶点 u 在 DFS 树中的深度优先数，$low[u]$ 表示从顶点 u 出发，通过当前 DFS 树中的边以及反向边，能够到达的最早的祖先顶点的深度优先数。当 $dfn[u]==low[u]$ 时，以 u 为根的子树中的所有顶点构成一个强连通分量。Tarjan 算法可以在 $O(|V|+|E|)$ 的时间复杂度内完成强连通分量的分解。示例代码如下（Python 代码）：

index = 0
def tarjan(graph, u, dfn, low, stack, in_stack, sccs):
    global index
    dfn[u] = index
    low[u] = index
    index += 1
    stack.append(u)
    in_stack[u] = True
    for v in graph[u]:
        if dfn[v] == -1:
            tarjan(graph, v, dfn, low, stack, in_stack, sccs)
            low[u] = min(low[u], low[v])
        elif in_stack[v]:
            low[u] = min(low[u], dfn[v])
    if dfn[u] == low[u]:
        scc = []
        while True:
            top = stack.pop()
            in_stack[top] = False
            scc.append(top)
            if top == u:
                break
        sccs.append(scc)


def tarjan_scc(graph):
    dfn = {u: -1 for u in graph}
    low = {u: -1 for u in graph}
    stack = []
    in_stack = {u: False for u in graph}
    sccs = []
    for u in graph:
        if dfn[u] == -1:
            tarjan(graph, u, dfn, low, stack, in_stack, sccs)
    return sccs

F. 在哈密顿路径问题中，启发式算法如最近邻算法（Nearest Neighbor Algorithm）可以在多项式时间内找到一个近似解。最近邻算法从任意一个顶点开始，每次选择距离当前顶点最近的未访问过的顶点作为下一个顶点，直到访问完所有顶点。这种算法总能找到一条经过所有顶点的路径，但不能保证找到的路径是哈密顿路径，因为它可能会导致某些顶点无法被访问或者重复访问某些顶点。然而，对于一些特殊结构的图，如完全图，最近邻算法可以找到哈密顿路径。
G. 在最小费用流问题中，当使用连续最短路算法时，如果边的费用 w 存在负数，并且直接使用 Dijkstra 算法寻找最短路径，可能会导致错误的结果。因为 Dijkstra 算法基于贪心策略，只能处理非负权图。即使在找到最短路径后，按照路径增加流的操作也可能会破坏最小费用的性质。
H. 在强连通分量分解中，使用深度优先搜索的简单变体，只对图进行一次 DFS 遍历，通过记录顶点的访问顺序和回溯顺序来确定强连通分量。具体做法是，在 DFS 过程中，为每个顶点标记一个访问顺序编号，当回溯时，如果发现某个顶点的所有邻接顶点都被访问过，且其访问顺序编号与当前回溯到的顶点编号之差大于某个阈值（例如，图中顶点数的一半），则认为从当前顶点到该顶点之间的所有顶点构成一个强连通分量。这种方法的时间复杂度为 $O(|V|+|E|)$，与 Kosaraju 算法和 Tarjan 算法具有相同的时间复杂度。

主观题（详细写出你的回答，共50分）

信息学应用（共40分）

26. 假设你正在设计一个面向未来人工智能计算的异构计算系统，该系统融合了通用 CPU、高性能 GPU、专门的 AI 加速芯片（如 TPU 架构变体）以及大容量的高速存储设备。此系统旨在处理大规模的深度学习任务，包括复杂的神经网络训练与推理。回答下列问题：
    计算资源分配：在训练一个具有数十亿参数的大型语言模型时，如何动态且高效地将计算任务分配到不同的计算单元（CPU、GPU、AI 加速芯片）上？请详细阐述分配策略的设计思路，包括考虑哪些因素以及如何根据任务特点进行决策。
    数据传输与存储优化：由于深度学习任务涉及海量的数据读写，在这个异构系统中，如何优化数据在不同存储层次（从高速缓存到主存再到大容量存储设备）之间的传输，以避免数据传输成为性能瓶颈？请说明具体的优化技术和方法，以及它们如何协同工作。
    能耗管理：随着计算规模的增大，能耗成为关键问题。针对此异构系统，设计一套能耗管理方案，该方案需在不显著影响系统性能的前提下，尽可能降低能耗。描述方案中如何对不同计算单元进行能耗监控与调节，以及如何根据任务的优先级和实时性能需求动态调整能耗策略。
    系统协同与通信开销：不同类型的计算单元之间需要频繁通信以协同完成任务。分析可能产生通信开销的环节，并提出减少这些开销的方法。同时，讨论如何设计系统架构以更好地支持计算单元之间的高效通信，确保整个系统的性能。（20分）

27. 假设你正在设计一种全新的编程语言，目标是用于开发高性能、分布式且具有强类型安全的系统软件。该语言需要支持多种编程范式，如面向对象、函数式和并发编程。回答下列问题：
    类型系统设计：描述你将如何设计一个既强大又灵活的类型系统，以确保类型安全，同时支持泛型编程和类型推导。请详细阐述类型检查的时机（编译时、运行时或两者结合），以及如何处理类型兼容性和类型转换问题。举例说明如何在这个类型系统中表示和处理复杂的数据结构，如异构链表（链表节点可以是不同类型），同时保证类型安全。
    内存管理机制：对于这种面向系统软件的语言，设计一种内存管理机制，既要保证高效的内存使用，又要避免常见的内存错误，如内存泄漏和悬空指针。讨论自动内存管理（如垃圾回收）和手动内存管理（如指针操作）如何结合使用，以及在不同场景下开发者如何选择合适的方式。描述如何在内存管理机制中处理多线程环境下的内存访问，以确保线程安全。例如，如何防止多个线程同时修改同一块内存导致的数据竞争问题。
    并发编程支持：设计一套并发编程模型，以支持分布式系统中的高效并发处理。说明如何在语言层面实现线程、进程或其他并发原语，以及如何管理并发任务之间的同步和通信。讨论如何处理并发编程中的死锁问题，包括检测死锁的机制和预防死锁的策略。在语言设计中，如何提供工具和语法来帮助开发者避免死锁。
    与其他语言的互操作性：考虑到实际应用中可能需要与现有的各种语言（如 C、Java 等）进行交互，设计一种机制来实现这种互操作性。描述如何在新语言中调用其他语言编写的函数和库，以及如何让其他语言调用新语言编写的代码。讨论在实现互操作性时可能面临的问题，如数据类型转换、内存管理的差异等，以及如何解决这些问题。（20分）

自然英语（共10分）

28. 翻译下列句子（英文译作中文）
    ① In the realm of artificial intelligence, deep learning algorithms such as convolutional neural networks and recurrent neural networks have revolutionized computer vision and natural language processing by enabling computers to automatically extract and analyze complex features from vast amounts of data.
    ② The advent of 5G technology is set to transform the landscape of the Internet of Things, allowing for seamless connectivity and ultra-fast data transmission between an array of smart devices and computer systems, thereby facilitating the realization of smart cities and intelligent transportation systems.
    ③ Virtual reality and augmented reality technologies rely on advanced graphics processing units and high-performance computing to create immersive digital environments, blurring the boundaries between the physical and virtual worlds and offering unprecedented interactive experiences for users in various fields such as gaming, education, and architecture.
    ④ Blockchain technology, with its decentralized and distributed ledger system, has the potential to revolutionize not only the financial sector by enabling secure and transparent transactions without the need for intermediaries but also various other industries such as supply chain management and healthcare by ensuring data integrity and security in computerized systems.
    ⑤ Software-defined networking (SDN) and network function virtualization (NFV) are transforming the traditional network infrastructure by separating the control plane from the data plane and enabling network administrators to centrally manage and configure network resources through software, thereby increasing network flexibility, scalability, and efficiency in computer networks.（10分）

程序写作题（请提交文件，语言不限，文件名为题号，共160分）

29. 图论与数论结合的路径加密问题
    一、题目描述
    给定一个无向图 $G=(V,E)$，其中 V 是顶点集，包含 n 个顶点，编号从 0 到 (n - 1)；E 是边集，每条边 $e=(u,v)$ 有一个正整数权值 $w(e)$。同时，给定一个大质数 p 和一个整数 a（$1<a<p$）。
    （一）路径计算
    对于图 G 中的任意一条简单路径 $P=v_0,v_1,\cdots ,v_k$（其中 $v_i$ 是顶点，$(v_i,v_{i+1})\in E$，$i=0,1,\cdots ,k-1$），定义路径的权值 $W(P)$ 为路径上所有边权值的乘积，即$W(P)={\prod }_{i=0}^{k-1}w((v_i,v_{i+1}))$。定义路径的加密值 $C(P)$ 为 $a^{W(P)}\mathrm{mod}p$。
    （二）任务要求
    编写一个程序，计算图 G 中从顶点 s 到顶点 t 的所有简单路径的加密值 $C(P)$，并将这些加密值按升序输出。为了降低计算复杂度，在计算 $a^{W(P)}\mathrm{mod}p$ 时，需使用快速幂算法。
    二、输入格式
    第一行包含三个整数 n，m，p，分别表示顶点数、边数和质数 p。第二行包含一个整数 a（$1<a<p$）。接下来 m 行，每行包含三个整数 u，v，w，表示存在一条边连接顶点 u 和 v，权值为 w。最后一行包含两个整数 s 和 t，表示源顶点和目标顶点。
    三、输出格式
    将从顶点 s 到顶点 t 的所有简单路径的加密值按升序输出，每个加密值占一行。
    四、数据范围
    $2\le n\le 18$，$1\le m\le \frac{n(n-1)}{2}$，$10^9<p<10^{18}$，$1<a<p$，$1\le w\le 100$，$0\le s,t<n$，且 $s\ne t$
    五、示例
    （一）输入示例

4 5 1000000007
2
0 1 2
0 2 3
1 2 4
1 3 5
2 3 6
0 3

（二）输出示例

16
32
64
128
256
512

（60分）

30. 星际贸易与资源管理模拟
    一、题目描述
    你将模拟一个星际贸易与资源管理的复杂系统。在一个广袤的宇宙中，存在多个星球，每个星球有不同的资源类型和数量，同时还有不同的科技水平和贸易政策。玩家可以控制一艘星际贸易飞船，在各个星球之间航行，进行资源的买卖、科技的交流以及探索新的星球。
    （一）星球信息
    每个星球有以下属性：
    资源：包含多种不同类型的资源，如金属、能源、晶体等。每种资源有一个初始数量和当前数量。
    科技水平：分为多个等级，影响该星球的资源生产速度、贸易价格和可交易的资源种类。
    贸易政策：包括资源的买入价格、卖出价格，以及是否允许某些特定资源的交易。
    位置：在宇宙中的三维坐标，用于计算飞船的航行时间。
    （二）飞船信息
    飞船有以下属性：
    载货容量：限制了飞船能够携带的资源总量。
    航行速度：决定了飞船在星球之间的航行时间。
    当前位置：飞船当前所在的星球或宇宙中的坐标。
    携带资源：记录飞船当前携带的各种资源的数量。
    （三）游戏流程
    初始设置：程序开始时，随机生成一定数量的星球，每个星球的资源、科技水平、贸易政策和位置都是随机的。同时初始化飞船的属性。
    玩家操作：玩家可以选择以下操作：
    航行：选择一个目标星球，飞船将按照航行速度向目标星球移动。航行时间根据星球之间的距离和飞船的航行速度计算。
    贸易：在到达一个星球后，玩家可以查看该星球的贸易政策，进行资源的买入或卖出。买入和卖出的价格根据星球的贸易政策和科技水平决定。
    探索：在某些情况下，玩家可以选择探索新的星球。探索成功后，会发现一个新的星球，并更新星球列表。
    资源生产：每个星球会根据自己的科技水平和资源类型，定期生产一定数量的资源。
    游戏结束条件：游戏可以设置一个时间限制，当时间到达时，游戏结束。或者当飞船的资源耗尽且无法补充时，游戏也结束。
    二、输入格式
    输入文件包含以下信息：
    第一行包含三个整数 N、M、T，分别表示初始星球的数量、资源的种类和游戏的时间限制（单位：回合）。
    接下来的 N 行，每行描述一个星球的信息，格式如下：
    x y z tech_level：表示星球的三维坐标 (x, y, z) 和科技水平。
    接下来的 M 行，每行包含两个整数 initial_amount 和 price，分别表示该星球某种资源的初始数量和当前的卖出价格。
    最后一行包含 M 个整数，表示该星球每种资源的买入价格。
    最后一行描述飞船的信息，格式如下：
    capacity speed x y z：表示飞船的载货容量、航行速度和初始位置。
    三、输出格式
    输出文件包含以下信息：
    第一行输出一个整数 S，表示游戏结束时飞船携带的资源总价值。
    接下来的 M 行，每行输出一个整数，表示游戏结束时飞船携带的每种资源的数量。
    四、示例
    （一）示例输入

3 2 10
0 0 0 2
100 10
200 20
12 22
10 10 10 3
150 15
250 25
18 28
20 20 20 1
50 5
100 10
8 12
1000 10 0 0 0

（二）示例输出

2300
100
65

（100分）