本文共 2025 字，大约阅读时间需要 6 分钟。

敌兵布阵问题的代码实现

情况分析

我们需要处理多个测试用例，每个测试用例包含若干命令，用于管理敌人的工兵营地的数量。本题的主要操作包括：

代码实现

数据结构与工具

为了高效处理大量数据和多次查询，我们采用了折半查找法（即二分查找）配合线段树结构。线段树的每个节点维持其区间内的总工兵数量，并支持快速更新和查询操作。

核心代码

线段树定义

struct node {
    int l, r;
    int sum;
};

线段树操作

void build(int u, int l, int r) {
    tr[u].l = l;
    tr[u].r = r;
    if (l == r) {
        tr[u].sum = w[l];
        return;
    }
    int mid = l + r > 1 ? l + (r - l) / 2 : l;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

2. **更新操作**：
   ```c++
   void updata(int u, int pos, int val) {
       if (tr[u].l == tr[u].r) {
           tr[u].sum += val;
           return;
       }
       int mid = tr[u].l + tr[u].r > 1 ? tr[u].l + (tr[u].r - tr[u].l) / 2 : tr[u].l;
       if (pos <= mid) {
           updata(u << 1, pos, val);
       } else {
           updata(u << 1 | 1, pos, val);
       }
       tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
   }

3. 查询操作：

   int quary(int u, int l, int r) {
       if (tr[u].l > r || tr[u].r < l) {
           return 0;
       }
       int res = 0;
       int mid = tr[u].l + tr[u].r > 1 ? tr[u].l + (tr[u].r - tr[u].l) / 2 : tr[u].l;
       if (l <= mid) {
           res += quary(u << 1, l, r);
       }
       if (r > mid) {
           res += quary(u << 1 | 1, l, r);
       }
       return res;
   }

### 实现步骤
1. **读取输入**：
   开始读取测试用例数`t`，每个测试用例读取`n`，随后读取`n`个初始工兵数量。
2. **初始化线段树**：
   使用递归函数`build`初始化线段树，将每个单独的工兵营地值映射到叶子节点，然后逐步向上合并每个区间的总和。
3. **处理命令**：
   读取每条命令并执行相应操作：
   - `Add i j`：调用`updata`函数，向第`i`个工兵营地增加`j`人。
   - `Sub i j`：同样调用`updata`函数，向第`i`个工兵营地减少`j`人。
   - `Query i j`：调用`quary`函数，查询第`i`到第`j`个工兵营地的总人数。
   - `End`：结束当前测试用例的处理。
## 样例测试
### 样例输入

1 10 1 2 3 4 5 6 7 8 9 10 Query 1 3 Add 3 6 Query 2 7 Sub 10 2 Add 6 3 Query 3 10 End

### 样例输出

Case 1: 6 33 59

## 代码解析
这个代码实现了线段树的基本操作，能够在O(log n)时间内完成更新和查询操作。线段树的高效性能使得多次查询和频繁更新完全不会影响系统性能。通过这种方式，我们可以快速响应每个`Query`命令，并保持代码的高效性。

转载地址：http://goagz.baihongyu.com/