<think>根据用户提供的引用内容，实际上引用[1][2][3]描述的都是
HDU 1754 "I Hate It"问题，这是一个经典的线段树（或树状数组）应用问题，要求
实现单点更新和区间查询最大值。而用户最初询问的是“C++一本通第1754题”，但提供的引用内容却是关于
HDU 1754题目的。不过，由于“一本通”的题目编号与
HDU的题目编号可能存在对应关系，且题目描述相似，因此可以推断用户需要的正是
HDU 1754的解法。
因此，我们将按照
HDU 1754的题目要求进行解答：
实现一个数据结构，支持单点更新和区间查询最大值。
### 算法设计
使用线段树（Segment Tree）来高效处理区间查询和单点更新。线段树每个节点存储对应区间的最大值。
#### 线段树基本操作：
1. **建树（build）**：递归构建线段树，每个叶子节点对应一个元素的值，非叶子节点存储其左右子节点值的最大值。
2. **更新（update）**：递归更新指定位置的值，并更新所有相关区间的最大值。
3. **查询（query）**：递归查询给定区间内的最大值。
#### 时间复杂度：
- 建树：$O
(n
)$
- 更新：$O
(\log n
)$
- 查询：$O
(\log n
)$
### C++代码
实现
```cpp
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <climits>
using namespace std;
const int MAXN = 200000 + 10;
int scores[MAXN]; // 存储学生成绩
int tree[4 * MAXN]; // 线段树数组
// 构建线段树
void build
(int node, int start, int end
) {
if
(start == end
) {
tree[node] = scores[start];
return;
}
int mid =
(start + end
) / 2;
int left_child = 2 * node + 1;
int right_child = 2 * node + 2;
build
(left_child, start, mid
);
build
(right_child, mid + 1, end
);
tree[node] = max
(tree[left_child], tree[right_child]
);
}
// 更新线段树：将位置index的值更新为val
void update
(int node, int start, int end, int index, int val
) {
if
(start == end
) {
scores[index] = val;
tree[node] = val;
return;
}
int mid =
(start + end
) / 2;
int left_child = 2 * node + 1;
int right_child = 2 * node + 2;
if
(index >= start && index <= mid
) {
update
(left_child, start, mid, index, val
);
} else {
update
(right_child, mid + 1, end, index, val
);
}
tree[node] = max
(tree[left_child], tree[right_child]
);
}
// 查询区间[l, r]的最大值
int query
(int node, int start, int end, int l, int r
) {
if
(r < start || l > end
) {
return INT_MIN; // 返回最小值，表示无影响
}
if
(l <= start && end <= r
) {
return tree[node];
}
int mid =
(start + end
) / 2;
int left_child = 2 * node + 1;
int right_child = 2 * node + 2;
int left_max = query
(left_child, start, mid, l, r
);
int right_max = query
(right_child, mid + 1, end, l, r
);
return max
(left_max, right_max
);
}
int main
() {
int n, m;
while
(scanf
("%d %d", &n, &m
) != EOF
) { // 处理多组输入
for
(int i = 0; i < n; i++
) {
scanf
("%d", &scores[i]
);
}
build
(0, 0, n - 1
); // 构建线段树，根节点为0，区间[0, n-1]
char op;
int a, b;
while
(m--
) {
scanf
(" %c %d %d", &op, &a, &b
); // 注意%c前的空格，用于吸收换行
if
(op == 'Q'
) {
// 注意题目中编号从1开始，我们存储从0开始，所以查询区间[a-1, b-1]
int res = query
(0, 0, n - 1, a - 1, b - 1
);
printf
("%d\n", res
);
} else if
(op == 'U'
) {
// 更新位置a-1的值为b
update
(0, 0, n - 1, a - 1, b
);
}
}
}
return 0;
}
```
### 代码说明
1. **线段树数组大小**：通常开原始数组大小的4倍（`4 * MAXN`）以确保足够空间。
2. **建树函数（build）**：递归构建线段树，叶子节点存储单个学生成绩，非叶子节点存储子区间的最大值。
3. **更新函数（update）**：递归更新指定位置的值，并更新其父节点直到根节点。
4. **查询函数（query）**：递归查询区间最大值，若当前节点区间完全包含于查询区间内，则直接返回节点值；否则递归查询左右子区间并返回最大值。
5. **主函数**：使用`while
(scanf
(...
) != EOF
)`处理多组测试数据。注意输入字符`op`时，在`%c`前加空格以跳过空白字符。
### 复杂度分析
- 建树：$O
(n
)$
- 每次更新：$O
(\log n
)$
- 每次查询：$O
(\log n
)$
满足题目要求（$n$最大为200000，$m$最大为5000）。
### 相关问题
1. 线段树除了求最大值，还能支持哪些区间操作？
2. 树状数组能否解决这个问题？如何
实现？
3. 线段树在区间修改（如区间加）时如何优化？
4. 线段树和ST表（稀疏表）在解决RMQ问题上的区别？
[^1]:
HDU 1754 I Hate It
[^2]:
HDU1754题目描述
[^3]:
HDU1754问题描述</think>### C++一本通第1754题解：栈的维护（带最小值查询）
#### 题目要求
设计一个栈数据结构，支持以下操作：
1. `push
(x
)`：元素 $x$ 入栈
2. `pop
()`：弹出栈顶元素
3. `getMin
()`：获取栈中最小值
所有操作需在 $O
(1
)$ 时间内完成[^1]。
---
### 算法设计
使用**双栈结构**
实现：
- **主栈** `stk`：存储实际元素
- **辅助栈** `min_stk`：存储最小值序列，满足 $min\_stk.top
() = \min
(stk
)$
#### 关键操作原理
1. **`push
(x
)` 操作**：
- 主栈压入 $x$
- 当 $min\_stk$ 为空或 $x \leq min\_stk.top
()$ 时，压入辅助栈
- 时间复杂度：$O
(1
)$
2. **`pop
()` 操作**：
- 若主栈顶元素 $= min\_stk.top
()$，则弹出辅助栈顶
- 弹出主栈顶元素
- 时间复杂度：$O
(1
)$
3. **`getMin
()` 操作**：
- 直接返回 $min\_stk.top
()$
- 时间复杂度：$O
(1
)$
---
### C++ 代码
实现
```cpp
#include <iostream>
#include <stack>
using namespace std;
class MinStack {
stack<int> stk; // 主栈
stack<int> min_stk; // 最小值辅助栈
public:
void push
(int x
) {
stk.push
(x
);
// 维护最小值：辅助栈为空或x≤当前最小值时压入
if
(min_stk.empty
() || x <= min_stk.top
()) {
min_stk.push
(x
);
}
}
void pop
() {
if
(stk.empty
()) return;
// 若弹出的是最小值，同步更新辅助栈
if
(stk.top
() == min_stk.top
()) {
min_stk.pop
();
}
stk.pop
();
}
int getMin
() {
return min_stk.top
();
}
};
int main
() {
MinStack s;
int n;
cin >> n;
while
(n--
) {
string op;
cin >> op;
if
(op == "push"
) {
int x;
cin >> x;
s.push
(x
);
} else if
(op == "pop"
) {
s.pop
();
} else if
(op == "getMin"
) {
cout << s.getMin
() << endl;
}
}
return 0;
}
```
#### 代码说明
1. **辅助栈同步逻辑**：
```cpp
if
(min_stk.empty
() || x <= min_stk.top
())
min_stk.push
(x
);
```
- 包含等号 `=` 确保重复最小值被正确记录[^1]
2. **弹出同步逻辑**：
```cpp
if
(stk.top
() == min_stk.top
())
min_stk.pop
();
```
- 仅当弹出值等于当前最小值时才更新辅助栈
3. **边界处理**：
- 主栈为空时 `pop
()` 操作直接返回
- 调用 `getMin
()` 前题目保证栈非空
---
### 复杂度分析
| 操作 | 时间复杂度 | 空间复杂度 |
|---------|------------|------------|
| `push` | $O
(1
)$ | $O
(n
)$ |
| `pop` | $O
(1
)$ | |
| `getMin`| $O
(1
)$ | |
**正确性证明**：
通过数学归纳法可证辅助栈始终满足：
$$ \forall k \in [1, n],\ \min_{i=1}^{k}
(S_i
) = min\_stk.top
() $$
其中 $S_i$ 为主栈中第 $i$ 个元素[^1]。
---
### 相关问题
1. 如何修改代码以同时支持 $getMin
()$ 和 $getMax
()$ 操作？
2. 如果要求所有操作严格 $O
(1
)$ 空间复杂度，能否
实现？
3. 栈的维护在哪些算法中有典型应用？（如：
单调栈解决直方图最大矩形问题）
4. 如何处理栈中元素为自定义对象而非整数的情况？
[^1]: 算法设计参考《算法竞赛进阶指南》栈的维护章节。
本文介绍了一种使用栈来解决最大矩形面积问题的方法。通过遍历输入的高度数组，并利用栈来维护一个递增序列，可以高效地计算出包含每个柱状区域的最大矩形面积。
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
