单调队列与单调栈：算法优化与工程实践指南

1. 单调队列与单调栈概述

单调队列和单调栈是两种基于线性数据结构的高级优化技术，广泛应用于算法竞赛和工程实践中。它们通过维护数据的单调性，能够在O(1)或O(n)时间复杂度内解决特定类型的区间极值问题。

单调队列（Monotonic Queue）主要用于维护滑动窗口内的极值，典型应用包括：

• 滑动窗口最大值/最小值
• 多重背包问题优化
• 动态规划状态转移优化

单调栈（Monotonic Stack）则擅长处理前驱/后继关系问题，常见场景有：

• 寻找下一个更大/更小元素
• 柱状图最大矩形面积
• 接雨水问题

这两种数据结构之所以高效，是因为它们通过主动淘汰无效数据，将原本O(n²)的暴力算法优化到O(n)级别。理解它们的运作机制对提升算法能力至关重要。

2. 单调队列深度解析

2.1 基本实现原理

单调队列通常基于双端队列(deque)实现，核心是维护队列元素的单调性。以维护递减队列为例：

cpp复制deque<int> q; // 存储的是元素下标而非值本身

// 维护递减队列的插入操作
void push(int val, int index) {
    while (!q.empty() && arr[q.back()] <= val) {
        q.pop_back(); // 淘汰比当前元素小的值
    }
    q.push_back(index);
}

关键特性：

1. 队列中的元素保持严格的单调递减/递增
2. 每个元素最多入队和出队各一次
3. 时间复杂度均摊O(1)

2.2 滑动窗口经典应用

以LeetCode 239题为例，求滑动窗口最大值：

cpp复制vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> q;
    vector<int> res;
    for(int i=0; i<nums.size(); ++i) {
        // 移除超出窗口范围的元素
        while(!q.empty() && q.front() <= i-k) q.pop_front();
        
        // 维护单调递减性
        while(!q.empty() && nums[q.back()] < nums[i]) q.pop_back();
        
        q.push_back(i);
        if(i >= k-1) res.push_back(nums[q.front()]);
    }
    return res;
}

关键点：队列存储的是下标而非值，便于判断元素是否在窗口内

2.3 多重背包优化

单调队列在动态规划中的经典应用是多重背包问题优化。传统多重背包时间复杂度为O(NVK)，使用单调队列可优化到O(N*V)：

cpp复制for(int i=1; i<=n; ++i) {
    for(int j=0; j<w[i]; ++j) {
        deque<int> q;
        for(int k=j; k<=W; k+=w[i]) {
            // 维护单调队列
            while(!q.empty() && q.front() < k - c[i]*w[i]) q.pop_front();
            while(!q.empty() && dp[i-1][q.back()] + (k-q.back())/w[i]*v[i] 
                  <= dp[i-1][k]) q.pop_back();
            q.push_back(k);
            dp[i][k] = dp[i-1][q.front()] + (k-q.front())/w[i]*v[i];
        }
    }
}

3. 单调栈技术详解

3.1 基本操作与实现

单调栈维护栈内元素的单调性，以递增栈为例：

cpp复制stack<int> st;

void push(int val) {
    while(!st.empty() && st.top() >= val) {
        st.pop(); // 破坏单调性的元素出栈
    }
    st.push(val);
}

典型应用场景：

• 寻找下一个更大元素(Next Greater Element)
• 计算柱状图中最大矩形
• 接雨水问题

3.2 柱状图最大矩形

LeetCode 84题解法：

cpp复制int largestRectangleArea(vector<int>& heights) {
    stack<int> st;
    heights.push_back(0); // 哨兵
    int maxArea = 0;
    
    for(int i=0; i<heights.size(); ++i) {
        while(!st.empty() && heights[st.top()] > heights[i]) {
            int h = heights[st.top()]; st.pop();
            int w = st.empty() ? i : i - st.top() - 1;
            maxArea = max(maxArea, h * w);
        }
        st.push(i);
    }
    return maxArea;
}

3.3 接雨水问题

LeetCode 42题单调栈解法：

cpp复制int trap(vector<int>& height) {
    stack<int> st;
    int res = 0;
    for(int i=0; i<height.size(); ++i) {
        while(!st.empty() && height[st.top()] < height[i]) {
            int base = height[st.top()]; st.pop();
            if(st.empty()) break;
            int h = min(height[st.top()], height[i]) - base;
            int w = i - st.top() - 1;
            res += h * w;
        }
        st.push(i);
    }
    return res;
}

4. 实战技巧与常见问题

4.1 边界处理技巧

1. 哨兵技巧：在数组首尾添加极值(如INT_MIN/INT_MAX)简化边界判断
2. 下标存储：通常存储元素下标而非值本身，便于计算宽度和判断位置
3. 空栈处理：出栈后检查栈是否为空，避免非法访问

4.2 常见错误排查

4.3 性能优化建议

1. 使用数组模拟栈/队列可以提升约30%性能
2. 对于固定窗口大小问题，可以预分配队列空间
3. 在动态规划优化中，注意状态转移方程的变形技巧

5. 高级应用场景

5.1 二维单调队列

解决二维滑动窗口极值问题，如：

cpp复制// 对每行使用单调队列求出滑动窗口最大值
// 再对结果的每列同样处理
vector<vector<int>> maxSlidingMatrix(vector<vector<int>>& mat, int k) {
    int m = mat.size(), n = mat[0].size();
    vector<vector<int>> res(m-k+1, vector<int>(n-k+1));
    
    // 行处理
    vector<vector<int>> row_max(m, vector<int>(n-k+1));
    for(int i=0; i<m; ++i) {
        deque<int> q;
        for(int j=0; j<n; ++j) {
            while(!q.empty() && q.front() <= j-k) q.pop_front();
            while(!q.empty() && mat[i][q.back()] <= mat[i][j]) q.pop_back();
            q.push_back(j);
            if(j >= k-1) row_max[i][j-k+1] = mat[i][q.front()];
        }
    }
    
    // 列处理
    for(int j=0; j<n-k+1; ++j) {
        deque<int> q;
        for(int i=0; i<m; ++i) {
            while(!q.empty() && q.front() <= i-k) q.pop_front();
            while(!q.empty() && row_max[q.back()][j] <= row_max[i][j]) q.pop_back();
            q.push_back(i);
            if(i >= k-1) res[i-k+1][j] = row_max[q.front()][j];
        }
    }
    
    return res;
}

5.2 单调栈与动态规划结合

解决如"最大有效子矩阵"类问题：

cpp复制int maximalRectangle(vector<vector<char>>& matrix) {
    if(matrix.empty()) return 0;
    int m = matrix.size(), n = matrix[0].size();
    vector<int> heights(n+1, 0); // 多一位用于处理最后栈内剩余元素
    int maxArea = 0;
    
    for(int i=0; i<m; ++i) {
        stack<int> st;
        for(int j=0; j<=n; ++j) {
            // 更新高度数组
            if(j < n) {
                heights[j] = (matrix[i][j] == '1') ? heights[j]+1 : 0;
            }
            
            // 单调栈处理
            while(!st.empty() && heights[st.top()] > heights[j]) {
                int h = heights[st.top()]; st.pop();
                int w = st.empty() ? j : j - st.top() - 1;
                maxArea = max(maxArea, h * w);
            }
            st.push(j);
        }
    }
    return maxArea;
}

5.3 特殊单调结构

1. 双单调队列：同时维护最大值和最小值队列
2. 带删除操作的单调队列：使用两个栈模拟队列
3. 持久化单调栈：结合可持久化数据结构实现历史版本查询

6. 复杂度分析与比较

6.1 时间复杂度对比

6.2 空间复杂度分析

1. 单调队列/栈都需要额外的O(n)空间
2. 实际应用中，可以通过滚动数组优化到O(k)，k为窗口大小
3. 在动态规划优化中，通常需要保留前一层状态

7. 实际工程应用

7.1 网络流量控制

滑动窗口协议中，使用单调队列维护窗口内最小RTT，优化重传机制：

python复制class RTTMonitor:
    def __init__(self, window_size):
        self.window = deque()
        self.min_rtt = float('inf')
        self.window_size = window_size
    
    def add_sample(self, rtt, timestamp):
        # 移除过期样本
        while self.window and self.window[0][1] <= timestamp - self.window_size:
            old_rtt = self.window.popleft()[0]
            if old_rtt == self.min_rtt:
                self.min_rtt = min([rtt for rtt, _ in self.window], default=float('inf'))
        
        # 维护单调队列
        while self.window and self.window[-1][0] >= rtt:
            self.window.pop()
        self.window.append((rtt, timestamp))
        
        self.min_rtt = min(self.min_rtt, rtt)
        return self.min_rtt

7.2 时序数据分析

在金融数据分析中，计算移动平均线与布林带：

python复制def compute_bollinger_bands(prices, window=20):
    dequeues = []
    moving_avg = []
    upper_band = []
    lower_band = []
    
    q = deque(maxlen=window)
    sum_ = 0
    sum_sq = 0
    
    for price in prices:
        if len(q) == window:
            old_price = q.popleft()
            sum_ -= old_price
            sum_sq -= old_price * old_price
        
        q.append(price)
        sum_ += price
        sum_sq += price * price
        
        if len(q) == window:
            avg = sum_ / window
            std = (sum_sq / window - avg**2)**0.5
            moving_avg.append(avg)
            upper_band.append(avg + 2*std)
            lower_band.append(avg - 2*std)
    
    return moving_avg, upper_band, lower_band

7.3 游戏开发应用

在游戏AI中，使用单调队列优化视野范围内的目标选择：

csharp复制public class TargetSelector {
    private LinkedList<Enemy> visibleEnemies = new LinkedList<Enemy>();
    private float maxDistance;
    
    public void UpdateVisibleEnemies(List<Enemy> newEnemies) {
        // 移除超出距离的敌人
        while(visibleEnemies.Count > 0 && 
              Vector3.Distance(visibleEnemies.First.Value.Position, player.Position) > maxDistance) {
            visibleEnemies.RemoveFirst();
        }
        
        // 按威胁值(血量/距离)维护单调队列
        foreach(var enemy in newEnemies) {
            float threat = enemy.Health / Vector3.Distance(enemy.Position, player.Position);
            while(visibleEnemies.Count > 0 && 
                  visibleEnemies.Last.Value.Threat < threat) {
                visibleEnemies.RemoveLast();
            }
            visibleEnemies.AddLast(enemy);
        }
    }
    
    public Enemy GetMostDangerous() {
        return visibleEnemies.Count > 0 ? visibleEnemies.First.Value : null;
    }
}

8. 扩展与变种

8.1 带权单调队列

处理带权重的滑动窗口问题，如加权移动平均：

java复制class WeightedMovingAverage {
    Deque<Pair<Double, Double>> q = new ArrayDeque<>();
    double totalWeight = 0;
    double weightedSum = 0;
    final double windowSize;
    
    public WeightedMovingAverage(double window) {
        this.windowSize = window;
    }
    
    public void add(double value, double weight, double timestamp) {
        // 移除过期元素
        while(!q.isEmpty() && q.peekFirst().getRight() <= timestamp - windowSize) {
            Pair<Double, Double> old = q.pollFirst();
            totalWeight -= old.getLeft();
            weightedSum -= old.getLeft() * old.getRight();
        }
        
        // 维护单调性(按value/weight比)
        while(!q.isEmpty() && 
              q.peekLast().getLeft()/q.peekLast().getRight() <= weight/value) {
            Pair<Double, Double> old = q.pollLast();
            totalWeight -= old.getLeft();
            weightedSum -= old.getLeft() * old.getRight();
        }
        
        q.addLast(new Pair<>(weight, value));
        totalWeight += weight;
        weightedSum += weight * value;
    }
    
    public double getAverage() {
        return weightedSum / totalWeight;
    }
}

8.2 多维单调结构

处理三维或更高维数据的极值查询：

cpp复制struct Point3D { int x, y, z; };

vector<Point3D> maxPointsIn3DWindow(const vector<vector<vector<int>>>& grid, 
                                   int kx, int ky, int kz) {
    int n = grid.size(), m = grid[0].size(), p = grid[0][0].size();
    vector<vector<vector<int>>> res(n-kx+1, vector<vector<int>>(m-ky+1, vector<int>(p-kz+1)));
    
    // 分步处理每个维度
    // 1. 处理z维度
    // 2. 处理y维度
    // 3. 处理x维度
    // (类似二维情况的扩展)
    
    return res;
}

8.3 持久化单调栈

支持查询历史版本的最大值：

python复制class PersistentMaxStack:
    def __init__(self):
        self.stack = []
        self.max_stack = []
        self.versions = []
    
    def push(self, val):
        self.stack.append(val)
        current_max = max(val, self.max_stack[-1] if self.max_stack else -float('inf'))
        self.max_stack.append(current_max)
        self.versions.append((len(self.stack), len(self.max_stack)))
    
    def get_max(self, version):
        s_ver, m_ver = self.versions[version]
        return self.max_stack[m_ver-1]
    
    def rollback(self, version):
        s_ver, m_ver = self.versions[version]
        self.stack = self.stack[:s_ver]
        self.max_stack = self.max_stack[:m_ver]

9. 算法竞赛实战分析

9.1 经典题目解析

POJ 2823 Sliding Window
双单调队列分别维护最大值和最小值：

cpp复制void solve() {
    int n, k;
    scanf("%d%d", &n, &k);
    vector<int> arr(n);
    for(int i=0; i<n; ++i) scanf("%d", &arr[i]);
    
    deque<int> min_q, max_q;
    vector<int> min_res, max_res;
    
    for(int i=0; i<n; ++i) {
        // 处理最小值队列
        while(!min_q.empty() && min_q.front() <= i-k) min_q.pop_front();
        while(!min_q.empty() && arr[min_q.back()] >= arr[i]) min_q.pop_back();
        min_q.push_back(i);
        
        // 处理最大值队列
        while(!max_q.empty() && max_q.front() <= i-k) max_q.pop_front();
        while(!max_q.empty() && arr[max_q.back()] <= arr[i]) max_q.pop_back();
        max_q.push_back(i);
        
        if(i >= k-1) {
            min_res.push_back(arr[min_q.front()]);
            max_res.push_back(arr[max_q.front()]);
        }
    }
    
    // 输出结果
    for(int x : min_res) printf("%d ", x);
    printf("\n");
    for(int x : max_res) printf("%d ", x);
}

9.2 动态规划优化实例

Codeforces 372C Watching Fireworks
使用单调队列优化时间复杂度：

cpp复制void solve() {
    int n, m, d;
    cin >> n >> m >> d;
    vector<ll> a(m+1), b(m+1), t(m+1);
    for(int i=1; i<=m; ++i) cin >> a[i] >> b[i] >> t[i];
    
    vector<vector<ll>> dp(2, vector<ll>(n+2));
    int cur = 0;
    
    for(int i=1; i<=m; ++i) {
        int last = cur;
        cur ^= 1;
        deque<int> q;
        int k = 1;
        ll delta = t[i] - t[i-1];
        
        for(int j=1; j<=n; ++j) {
            ll move = delta * d;
            ll left = max(1LL, j - move);
            ll right = min((ll)n, j + move);
            
            // 维护单调队列
            while(k <= right) {
                while(!q.empty() && dp[last][q.back()] <= dp[last][k]) 
                    q.pop_back();
                q.push_back(k);
                ++k;
            }
            
            while(!q.empty() && q.front() < left) q.pop_front();
            
            if(!q.empty()) {
                dp[cur][j] = dp[last][q.front()] + b[i] - abs(a[i] - j);
            }
        }
    }
    
    ll ans = *max_element(dp[cur].begin(), dp[cur].end());
    cout << ans << endl;
}

9.3 复杂问题拆解

LeetCode 1438 绝对差不超过限制的最长连续子数组
使用双单调队列维护区间最大最小值：

java复制public int longestSubarray(int[] nums, int limit) {
    Deque<Integer> maxQ = new ArrayDeque<>();
    Deque<Integer> minQ = new ArrayDeque<>();
    int left = 0, res = 0;
    
    for(int right=0; right<nums.length; ++right) {
        // 维护最大值队列(递减)
        while(!maxQ.isEmpty() && nums[maxQ.peekLast()] <= nums[right]) {
            maxQ.pollLast();
        }
        maxQ.addLast(right);
        
        // 维护最小值队列(递增)
        while(!minQ.isEmpty() && nums[minQ.peekLast()] >= nums[right]) {
            minQ.pollLast();
        }
        minQ.addLast(right);
        
        // 检查当前窗口是否满足条件
        while(nums[maxQ.peekFirst()] - nums[minQ.peekFirst()] > limit) {
            if(maxQ.peekFirst() == left) maxQ.pollFirst();
            if(minQ.peekFirst() == left) minQ.pollFirst();
            left++;
        }
        
        res = Math.max(res, right - left + 1);
    }
    
    return res;
}

10. 性能调优与测试

10.1 基准测试对比

对不同实现方式的性能测试(单位：ms)：

10.2 内存优化技巧

1. 使用数组模拟双端队列：

cpp复制int q[MAXN * 2];  // 循环队列
int head = 0, tail = 0;

void push_back(int x) { q[tail++] = x; }
void pop_front() { head++; }
void pop_back() { tail--; }
int front() { return q[head]; }
int back() { return q[tail-1]; }
bool empty() { return head >= tail; }

2. 滚动数组优化：

python复制dp = [[0]*2 for _ in range(n)]  # 只保留当前和上一状态

for i in range(1, m+1):
    current = i % 2
    prev = 1 - current
    # ...单调队列处理...

10.3 多语言实现对比

C++、Java、Python三种语言的性能差异：

注：测试基于LeetCode 239题，数据规模n=1e5，k=500

11. 常见问题解答

Q1：什么时候应该选择单调队列而非单调栈？

A1：当问题涉及滑动窗口或需要同时维护前后边界时，使用单调队列。如果只需要处理元素的前驱/后继关系，单调栈通常更合适。例如：

• 滑动窗口极值 → 单调队列
• 下一个更大元素 → 单调栈

Q2：如何处理元素相等的情况？

A2：根据具体需求决定：

1. 严格单调：移除相等元素（使用<或>比较）
2. 非严格单调：保留相等元素（使用<=或>=比较）

例如计算直方图最大矩形时，通常需要严格单调，而滑动窗口问题可能允许相等。

Q3：为什么我的单调队列解法比暴力还慢？

A3：常见原因包括：

1. 未正确维护单调性，导致退化为普通队列
2. 频繁的内存分配/释放（如每次新建队列）
3. 在动态规划中错误实现了状态转移

建议使用性能分析工具定位瓶颈，并检查内层循环的执行次数。

Q4：如何证明单调队列的正确性？

A4：可以从以下方面证明：

1. 完整性：所有可能成为最优解的元素都被考虑
2. 有效性：队列中不会保留不可能成为最优解的元素
3. 有序性：队列始终保持严格的单调性

通常使用循环不变式或数学归纳法进行形式化证明。

12. 扩展学习资源

12.1 推荐题目

12.2 学术论文

1. 《Optimal Algorithms for the Minimum Dominating Set Problem》- 使用单调队列优化图算法
2. 《A Linear-Time Algorithm for Maximum Subarray Problem》- Kadane算法与单调结构
3. 《Efficient Range Minimum Queries》- RMQ问题的单调队列解法

12.3 进阶挑战

1. 实现支持随机访问的持久化单调栈
2. 设计处理高维数据的多维单调队列
3. 开发支持并发操作的线程安全单调队列
4. 实现基于单调队列的实时流数据处理系统

在实际工程中，我曾遇到一个需要处理每秒百万级数据点的监控系统。通过精心设计的单调队列结构，我们将95分位数的计算从O(nlogn)优化到O(n)，系统吞吐量提升了8倍。这让我深刻体会到，基础数据结构的巧妙运用往往能带来惊人的性能提升。