華為OD機試真題——繪圖機器（2025A卷：100分）Java/python/JavaScript/C++/C/GO最佳實現

在這里插入圖片描述

2025 A卷 100分題型

本文涵蓋詳細的問題分析、解題思路、代碼實現、代碼詳解、測試用例以及綜合分析；
并提供Java、python、JavaScript、C++、C語言、GO六種語言的最佳實現方式！

本文收錄于專欄：《2025華為OD真題目錄+全流程解析/備考攻略/經驗分享》

華為OD機試真題《繪圖機器》：

- 題目名稱：繪圖機器
- - 題目描述
- Java
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- python
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- JavaScript
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- C++
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- C
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- GO
- - 問題分析
  - 解題思路
  - 代碼實現
  - 代碼詳細解析
  - 示例測試
  - - 示例1輸入：
    - 示例2輸入：
    - 示例3輸入：
  - 綜合分析
- 更多內容：

題目名稱：繪圖機器

知識點：邏輯分析
時間限制：1秒
空間限制：256MB
限定語言：不限

題目描述

繪圖機器的繪圖筆初始位置在原點 (0, 0)，啟動后按以下規則繪制直線：

橫向移動：沿橫坐標正向移動至終點 E。
縱向偏移：期間可通過指令在縱坐標方向偏移，參數 offsetY 為正表示正向偏移，為負表示負向偏移。

給定終點橫坐標 E 和若干條繪制指令，計算由繪制的直線、橫坐標軸及直線 x = E 圍成的圖形面積。

輸入描述

首行為兩個整數 N（指令數，0 < N ≤ 10000）和 E（終點橫坐標，0 ≤ E ≤ 20000）。
后續 N 行每行兩個整數，表示指令的橫坐標 x（遞增且不重復）和偏移量 offsetY（-10000 ≤ offsetY ≤ 10000）。

輸出描述

輸出面積值（整數），保證結果范圍在 0 至 4294967295 之間。

示例
輸入：

輸出：

說明

繪制路徑為從 (0,0) 到 (1,0) 的橫向線段（高度為 0，不貢獻面積），隨后依次在各指令點調整縱坐標：
1. (1,1) → (2,1)：區間 [1,2) 高度為 1，面積 1×1=1。
2. (2,2) → (3,2)：區間 [2,3) 面積 1×2=2。
3. (3,3) → (4,3)：區間 [3,4) 面積 1×3=3。
4. 終點處理：從 (4,1) 到 E=10，區間 [4,10) 高度為 1，面積 6×1=6。
  總面積為 1+2+3+6=12。

補充說明

相鄰指令的橫坐標遞增且無重復。
最終需處理從最后一條指令到終點 E 的橫向線段面積。

Java

問題分析

繪圖機器從原點出發，橫向移動到終點E，期間根據指令調整縱坐標。要求計算由路徑、x軸及x=E圍成的圖形面積。每個指令點的x坐標遞增且不重復，面積計算基于區間高度和橫向距離。

解題思路

區間劃分：將路徑劃分為多個區間，每個區間由相鄰指令點確定。
高度累積：每次到達指令點時調整縱向高度。
面積累加：每個區間的面積 = 橫向距離 × 當前高度。

代碼實現

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main {public static void main(String[] args) throws IOException {// 使用BufferedReader提高輸入讀取效率BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 讀取首行N和EString[] firstLine = br.readLine().split(" ");int N = Integer.parseInt(firstLine[0]);int E = Integer.parseInt(firstLine[1]);int prevX = 0;       // 前一個指令點的橫坐標int currentY = 0;    // 當前縱向高度long totalArea = 0;  // 總面積，用long防止溢出// 處理每個指令點for (int i = 0; i < N; i++) {String[] line = br.readLine().split(" ");int x = Integer.parseInt(line[0]);        // 當前指令點的橫坐標int offsetY = Integer.parseInt(line[1]);  // 當前縱向偏移量// 計算當前區間[prevX, x)的面積int len = x - prevX;totalArea += (long) len * currentY;// 更新高度和坐標currentY += offsetY;prevX = x;}// 處理最后一段到E的區間int finalLen = E - prevX;totalArea += (long) finalLen * currentY;// 輸出結果System.out.println(totalArea);}
}

代碼詳細解析

輸入處理：
- BufferedReader 逐行讀取輸入，首行分割得到指令數 N 和終點 E。
- 循環讀取每個指令點，分割得到橫坐標 x 和偏移量 offsetY。
初始化變量：
- prevX：記錄前一個指令點的橫坐標，初始為0（原點）。
- currentY：記錄當前縱向高度，初始為0。
- totalArea：累計總面積，使用 long 避免溢出。
核心循環邏輯：
- 對每個指令點，計算其與前一個指令點的橫向距離 len = x - prevX。
- 該區間的面積貢獻為 len × currentY，累加到 totalArea。
- 更新 currentY（加上當前偏移量）和 prevX（移動到當前x）。
最終區間處理：
- 計算最后指令點到終點E的距離 finalLen = E - prevX，面積貢獻為 finalLen × currentY。
- 結果累加后輸出。

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為0（0→1）、1（1→2）、2（2→3）、3（3→4）、6（4→10），總和12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：0（0→1）、2×2=4（1→3）、2×5=10（3→5），總和14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間面積0（0→5），最后區間5→5長度為0，總和0→代碼正確性需驗證。
（輸入描述可能有誤，假設E=10則輸出15）

綜合分析

時間復雜度：O(N)
- 僅需一次遍歷所有指令點，時間復雜度與指令數N成線性關系。
空間復雜度：O(1)
- 僅使用固定數量的變量，無需額外存儲所有指令點。
優勢：
- 高效：線性遍歷，無冗余計算。
- 內存友好：僅需常數空間。
- 魯棒性：處理大數用 long，避免溢出。
適用場景：
- 適用于指令數大（N ≤ 1e4）的場景，滿足時間與空間約束。

python

問題分析

我們需要計算繪圖機器繪制的路徑與x軸及x=E圍成的圖形面積。繪圖筆從原點開始，按指令調整縱向高度，最終到達E。每個區間的高度由當前指令的縱向偏移累積決定，面積由區間長度乘以當前高度累加得到。

解題思路

輸入處理：讀取指令數和終點E，以及每個指令點的橫坐標和縱向偏移。
區間劃分：將路徑劃分為多個區間，每個區間由相鄰指令點的橫坐標確定。
高度累積：每次到達指令點時更新縱向高度。
面積累加：計算每個區間和最后到E的面積總和。

代碼實現

def main():import sysinput = sys.stdin.read().split()ptr = 0N = int(input[ptr])ptr += 1E = int(input[ptr])ptr += 1prev_x = 0        # 前一個指令點的橫坐標，初始為0（原點）current_y = 0     # 當前縱向高度，初始為0total_area = 0    # 總面積for _ in range(N):x = int(input[ptr])        # 當前指令點的橫坐標ptr += 1offset_y = int(input[ptr]) # 縱向偏移量ptr += 1# 計算當前區間的橫向長度interval_length = x - prev_x# 累加當前區間的面積（長度 × 當前高度）total_area += interval_length * current_y# 更新縱向高度（加上偏移量）current_y += offset_y# 更新前一個橫坐標為當前xprev_x = x# 處理最后一段到E的區間final_length = E - prev_xtotal_area += final_length * current_yprint(total_area)if __name__ == "__main__":main()

代碼詳細解析

輸入處理：
- sys.stdin.read() 讀取所有輸入并按空格分割成列表。
- N 為指令數，E 為終點橫坐標。
- prev_x 初始為0（原點），current_y 初始為0，total_area 初始為0。
循環處理每個指令：
- 讀取當前指令點的 x 和 offset_y。
- 計算當前區間長度 interval_length = x - prev_x。
- 累加當前區間的面積：total_area += interval_length * current_y。
- 更新縱向高度 current_y += offset_y。
- 更新 prev_x 為當前 x。
處理最后一段區間：
- 計算從最后一個指令點到E的長度 final_length = E - prev_x。
- 累加最后區間的面積：total_area += final_length * current_y。
輸出結果：
- 打印總面積 total_area。

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為0（0→1）、1×1=1（1→2）、1×2=2（2→3）、1×3=3（3→4），最后一段6×1=6（4→10），總和12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：0（0→1）、2×2=4（1→3）、2×5=10（3→5），總和14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間0→5的面積是5×0=0，最后區間5→5長度為0，總面積為0。

綜合分析

時間復雜度：O(N)
- 僅需一次遍歷所有指令，時間復雜度與指令數N成線性關系。
空間復雜度：O(1)
- 僅使用常數級變量，無需額外存儲所有指令點。
優勢：
- 高效直接：線性遍歷，無冗余計算。
- 內存友好：僅需常數空間。
- 邏輯清晰：直接按物理意義逐段計算，避免復雜算法。
適用場景：
- 適用于指令數極大（如N=1e4）的場景，滿足時間與空間限制。

JavaScript

問題分析

解題思路

輸入處理：讀取指令數和終點E，以及每個指令點的橫坐標和縱向偏移。
區間劃分：將路徑劃分為多個區間，每個區間由相鄰指令點的橫坐標確定。
高度累積：每次到達指令點時更新縱向高度。
面積累加：計算每個區間和最后到E的面積總和。

代碼實現

const readline = require('readline');const rl = readline.createInterface({input: process.stdin,output: process.stdout,terminal: false
});let lines = []; // 存儲所有輸入行
let N, E;       // 指令數、終點坐標
let prevX = 0;  // 前一個指令點的橫坐標（初始為0）
let currentY = 0; // 當前縱向高度（初始為0）
let totalArea = 0; // 總面積rl.on('line', (line) => {lines.push(line.trim()); // 逐行讀取輸入
});rl.on('close', () => {// 解析第一行獲取N和Econst firstLine = lines[0].split(' ').map(Number);N = firstLine[0];E = firstLine[1];// 處理后續N行指令for (let i = 1; i <= N; i++) {const [x, offsetY] = lines[i].split(' ').map(Number);// 計算當前區間的橫向長度const intervalLength = x - prevX;// 累加當前區間的面積totalArea += intervalLength * currentY;// 更新高度和坐標currentY += offsetY;prevX = x;}// 處理最后一段到E的區間const finalLength = E - prevX;totalArea += finalLength * currentY;// 輸出結果console.log(totalArea);
});

代碼詳細解析

輸入處理：
- 使用 readline 模塊逐行讀取輸入，存入 lines 數組。
- 在 close 事件觸發時統一處理數據。

解析首行數據：

const firstLine = lines[0].split(' ').map(Number);
N = firstLine[0];
E = firstLine[1];

分割首行字符串，轉為數字數組，得到指令數 N 和終點 E。

遍歷處理每個指令：

for (let i = 1; i <= N; i++) {const [x, offsetY] = lines[i].split(' ').map(Number);// ...
}

逐行解析指令數據，獲取橫坐標 x 和偏移量 offsetY。

計算區間面積：
```
const intervalLength = x - prevX;
totalArea += intervalLength * currentY;
```
- 計算當前區間長度 intervalLength。
- 累加面積：長度 × 當前高度。
更新高度和坐標：
```
currentY += offsetY;
prevX = x;
```
- 調整縱向高度（累加偏移量）。
- 更新前一個橫坐標為當前 x。
處理最后一段到E的區間：
```
const finalLength = E - prevX;
totalArea += finalLength * currentY;
```
- 計算最后一段長度，并累加其面積。

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為0（0→1）、1×1=1（1→2）、1×2=2（2→3）、1×3=3（3→4），最后一段6×1=6（4→10），總和12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：0（0→1）、2×2=4（1→3）、2×5=10（3→5），總和14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間0→5的面積是5×0=0，最后區間5→5長度為0，總面積為0。

綜合分析

時間復雜度：O(N)
- 僅需一次遍歷所有指令，時間復雜度與指令數N成線性關系。
空間復雜度：O(N)
- 需存儲所有輸入行，但實際處理時僅逐行解析，內存占用可控。
優勢：
- 高效直接：線性遍歷，無冗余計算。
- 邏輯清晰：直接按物理意義逐段計算，避免復雜算法。
- 輸入處理安全：統一在 close 事件中處理數據，避免異步問題。
適用場景：
- 適用于指令數極大（如N=1e4）的場景，滿足時間與空間限制。

C++

問題分析

我們需要計算繪圖機器繪制的路徑與x軸及x=E圍成的區域的面積。繪圖筆從原點開始，橫向移動到終點E，期間根據指令調整縱向偏移。每個區間的高度由當前縱向偏移決定，面積由區間長度乘以高度累加得到。

解題思路

輸入處理：讀取指令數N、終點E，以及每個指令點的橫坐標和偏移量。
區間劃分：將路徑按指令點劃分為多個區間，計算每個區間的面積。
高度累積：每次到達指令點時更新縱向高度。
面積累加：累加所有區間的面積，包括最后一段到終點E的區間。

代碼實現

#include <iostream>
using namespace std;int main() {int N, E;         // 指令數、終點橫坐標cin >> N >> E;    // 讀取輸入int prev_x = 0;    // 前一個指令點的橫坐標（初始為0）int current_y = 0; // 當前縱向高度（初始為0）long long sum = 0; // 總面積，使用long long防止溢出for (int i = 0; i < N; ++i) {int x, offsetY;cin >> x >> offsetY;  // 讀取當前指令的x和偏移量// 計算當前區間的橫向長度sum += (long long)(x - prev_x) * current_y;current_y += offsetY;  // 更新縱向高度prev_x = x;            // 更新前一個指令點的橫坐標}// 處理最后一段到終點E的區間sum += (long long)(E - prev_x) * current_y;// 輸出結果cout << sum << endl;return 0;
}

代碼詳細解析

輸入處理：
- cin >> N >> E：讀取指令數 N 和終點橫坐標 E。
- prev_x 初始化為0（原點），current_y 初始化為0，sum 初始化為0。
循環處理每個指令：
- cin >> x >> offsetY：讀取當前指令點的橫坐標和偏移量。
- sum += (x - prev_x) * current_y：計算當前區間的面積并累加。
- current_y += offsetY：更新縱向高度。
- prev_x = x：更新前一個指令點的橫坐標。
處理最后一段區間：
- sum += (E - prev_x) * current_y：累加最后一段到終點E的面積。
輸出結果：直接輸出總面積。

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為0（0→1）、1×1=1（1→2）、1×2=2（2→3）、1×3=3（3→4），最后一段6×1=6（4→10），總和12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：0（0→1）、2×2=4（1→3）、2×5=10（3→5），總和14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間0→5的面積是5×0=0，最后區間5→5長度為0，總和為0。

綜合分析

時間復雜度：O(N)
- 僅需遍歷所有指令一次，時間復雜度與指令數N成線性關系。
空間復雜度：O(1)
- 僅使用固定數量的變量，無需額外存儲所有指令點。
優勢：
- 高效直接：逐指令處理，無需復雜數據結構。
- 內存友好：僅需常數空間。
- 抗溢出：使用 long long 確保大數計算正確。
適用場景：
- 適用于指令數極大（如N=1e4）的場景，滿足時間與空間限制。

C

問題分析

我們需要計算繪圖機器繪制的路徑與x軸及x=E圍成的區域的面積。繪圖筆從原點出發，橫向移動到E，期間根據指令調整縱坐標。每個區間的高度由當前縱坐標決定，面積由區間長度乘以高度累加得到。

解題思路

輸入處理：讀取指令數N、終點E，以及每個指令點的x坐標和偏移量。
逐指令處理：按順序計算每個區間的面積并累加。
最終區間處理：計算從最后一個指令點到E的區間面積。
輸出結果：輸出總面積。

代碼實現

#include <stdio.h>int main() {int N, E;scanf("%d %d", &N, &E);  // 讀取指令數和終點坐標int prev_x = 0;    // 前一個指令點的x坐標（初始為0）int current_y = 0; // 當前縱坐標高度（初始為0）long long sum = 0; // 總面積，用long long防止溢出for (int i = 0; i < N; i++) {int x, offset_y;scanf("%d %d", &x, &offset_y);  // 讀取當前指令點// 計算當前區間的面積并累加sum += (long long)(x - prev_x) * current_y;current_y += offset_y;  // 更新縱坐標高度prev_x = x;             // 更新前一個x坐標}// 處理最后一段到E的區間sum += (long long)(E - prev_x) * current_y;// 輸出結果printf("%lld\n", sum);return 0;
}

代碼詳細解析

輸入初始化：
```
int N, E;
scanf("%d %d", &N, &E);
```
- 讀取指令數 N 和終點坐標 E。

變量初始化：

int prev_x = 0;    // 初始位置為原點 (0,0)
int current_y = 0; // 初始縱坐標為0
long long sum = 0; // 總面積初始化為0

循環處理每個指令：

for (int i = 0; i < N; i++) {int x, offset_y;scanf("%d %d", &x, &offset_y);  // 讀取指令點的x坐標和偏移量

逐個讀取指令點的橫坐標 x 和偏移量 offset_y。

計算區間面積：
```
sum += (long long)(x - prev_x) * current_y;
```
- 當前區間長度為 x - prev_x，面積為 長度 × 當前高度。
- 強制轉換為 long long 防止乘法溢出。

更新高度和坐標：

current_y += offset_y;  // 縱坐標累加偏移量
prev_x = x;             // 更新前一個x坐標為當前值

處理最后一段到終點E：
```
sum += (long long)(E - prev_x) * current_y;
```
- 無論是否有剩余區間，強制計算到終點E的面積。
輸出結果：
```
printf("%lld\n", sum);
```
- 使用 %lld 格式符輸出 long long 類型的總面積。

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為：[0,1)=0、[1,2)=1×1=1、[2,3)=1×2=2、[3,4)=1×3=3、[4,10)=6×1=6，總和為 12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：[0,1)=0、[1,3)=2×2=4、[3,5)=2×5=10，總和 14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間 [0,5) 面積為 5×0=0，最后區間 [5,5) 長度為0，總和為 0。

綜合分析

時間復雜度：O(N)
- 僅需遍歷所有指令一次，時間復雜度與指令數 N 成線性關系。
空間復雜度：O(1)
- 僅使用固定變量，無需額外存儲所有指令點。
優勢：
- 內存高效：無需預存所有指令點，逐個處理節省內存。
- 計算安全：使用 long long 防止大數溢出。
- 邏輯直接：嚴格按題意逐段計算，無復雜算法。
適用場景：
- 指令數極大（如 N=1e4）或終點坐標極大（如 E=2e4）的場景。

GO

問題分析

我們需要計算繪圖機器繪制的路徑與x軸及x=E圍成的區域的面積。繪圖筆從原點開始，橫向移動到終點E，期間根據指令調整縱向偏移。每個區間的高度由當前指令點決定的縱向偏移累積確定，面積由區間長度乘以高度累加得到。

解題思路

輸入處理：讀取指令數 N 和終點坐標 E，以及每個指令點的橫坐標和縱向偏移。
逐指令處理：按順序處理每個指令點，計算當前區間面積并累加。
更新高度：根據偏移量更新縱向高度，用于后續區間計算。
最終區間處理：計算最后一個指令點到終點E的區間面積。
輸出結果：輸出所有區間的總面積。

代碼實現

package mainimport ("bufio""fmt""os""strconv""strings"
)func main() {scanner := bufio.NewScanner(os.Stdin)// 讀取第一行，包含N和Escanner.Scan()firstLine := strings.Fields(scanner.Text())N, _ := strconv.Atoi(firstLine[0])E, _ := strconv.Atoi(firstLine[1])prevX := 0    // 前一個指令點的橫坐標（初始為0）currentY := 0 // 當前縱向高度（初始為0）sum := int64(0) // 總面積，使用int64防止溢出// 處理每個指令點for i := 0; i < N; i++ {scanner.Scan()line := strings.Fields(scanner.Text())x, _ := strconv.Atoi(line[0])          // 當前指令點的橫坐標offsetY, _ := strconv.Atoi(line[1])    // 縱向偏移量// 計算當前區間的面積并累加interval := x - prevXsum += int64(interval * currentY)// 更新縱向高度和坐標currentY += offsetYprevX = x}// 處理最后一段到終點E的區間finalInterval := E - prevXsum += int64(finalInterval * currentY)// 輸出結果fmt.Println(sum)
}

代碼詳細解析

輸入初始化：
```
scanner := bufio.NewScanner(os.Stdin)
```
- 使用 bufio.Scanner 讀取標準輸入。

讀取首行數據：

scanner.Scan()
firstLine := strings.Fields(scanner.Text())
N, _ := strconv.Atoi(firstLine[0])
E, _ := strconv.Atoi(firstLine[1])

解析首行輸入，分割為 N（指令數）和 E（終點坐標）。

變量初始化：

prevX := 0    // 初始橫坐標為0（原點）
currentY := 0 // 初始縱向高度為0
sum := int64(0) // 總面積初始化為0，用int64防止溢出

循環處理每個指令點：

for i := 0; i < N; i++ {scanner.Scan()line := strings.Fields(scanner.Text())x, _ := strconv.Atoi(line[0])offsetY, _ := strconv.Atoi(line[1])

逐行讀取指令點，解析橫坐標 x 和偏移量 offsetY。

計算區間面積：
```
interval := x - prevX
sum += int64(interval * currentY)
```
- 計算當前區間的橫向長度 interval，面積累加到 sum。
更新高度和坐標：
```
currentY += offsetY
prevX = x
```
- 調整縱向高度 currentY，更新前一個橫坐標 prevX。
處理最后一段到終點E的區間：
```
finalInterval := E - prevX
sum += int64(finalInterval * currentY)
```
- 計算最后一段的長度，并累加其面積。
輸出結果：
```
fmt.Println(sum)
```

示例測試

示例1輸入：

輸出：

解析：

區間面積依次為：[0,1)=0、[1,2)=1×1=1、[2,3)=1×2=2、[3,4)=1×3=3、[4,10)=6×1=6，總和 12。

示例2輸入：

2 5  
1 2  
3 3

輸出：

解析：

區間面積：[0,1)=0、[1,3)=2×2=4、[3,5)=2×5=10，總和 14。

示例3輸入：

1 5  
5 3

輸出：

解析：

區間 [0,5) 面積為 5×0=0，最后區間 [5,5) 長度為0，總和為 0。

綜合分析

時間復雜度：O(N)
- 遍歷所有指令點一次，時間復雜度與指令數 N 成線性關系。
空間復雜度：O(1)
- 僅需常量級變量存儲當前狀態，無需額外存儲所有指令點。
優勢：
- 高效處理：逐個指令點處理，避免內存浪費。
- 抗溢出：使用 int64 確保大數計算正確。
- 邏輯清晰：嚴格按題目描述逐段計算，無冗余操作。
適用場景：
- 適用于指令數極大（如 N=1e4）或終點坐標極大（如 E=2e4）的場景。