原文链接：https://blog.csdn.net/xzerui/article/details/118684260
一、基本概念
单调队列是指：单调递增或单调递减的队列。所以它也有如下几个性质：
1.队列中的元素在原来的列表中的位置是由前往后的(随着循环顺序入队)。
2.队列中元素的大小是单调递增或递减的。
3.从队尾入列，队首或队尾出列
时间复杂度：O(N)
二、例题
1.最大子序和（dp+单调队列优化）
题目描述
输入一个长度为n的整数序列，从中找出一段不超过m的连续子序列，使得整个序列的和最大。
例如 1,-3,5,1,-2,3
当m=4时，S=5+1-2+3=7
当m=2或m=3时，S=5+1=6
输入
第一行两个数n,m（n,m≤300000）（n,m \leq 300000）（n,m≤300000）
第二行有n个数，要求在n个数找到最大子序和
输出
一个数，数出他们的最大子序和
样例输入
6 4
1 -3 5 1 -2 3
样例输出
7
题解：
计算区间和的问题，一般转化为连个前缀和相减的形式进行求解。我们可以先求出S[i]表示序列里前i ii项的和，则连续子序列[L,R]中的和就等于S [ R ] − S [ L − 1 ].所以我们可以非常巧妙地将原问题转化为：找出两个位子h和t，使S [ h ] − S [ t ] 最大并且h − t < = m
首先枚举右端点i，当i固定时，问题就变为：找到一个右端点j，其中j属于[ i − m , i − 1 ]这个集合,并且S [ j ]最小.
如果我们比较一下任意的两个位子j和k,如果k<j<i，并且S[k]>=S[j]，那么对于所有大于等于i的右端点，k永远不会成为最佳选择。这是因为不但S[k]不小于S[j]，而且j离i更近，长度更不容易超过M，即j的生存能力比k更强。所以当j出现后，k就是个完全无用的位子。
以上比较可以让我们得出结论：可能成为最优选择的策论集合一定是一个"下标位置递增、对应的前缀和S的值也递增"的序列。我们可以用一个队列保存这个序列。随着右端点变从前向后扫描，我们对于每个i可以执行以下步骤：
- 1.判断队头决策与i的距离是否超过M的范围，若超则出队
- 2.此时队头就是右端点i时，左端点j的最优选择
- 3.不断删除队尾决策，直到队尾对应的S值小于S[i]。然后把i作为一个新的决策入队
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt(),m=sc.nextInt();
sc.nextLine();
int[] nums=new int[n+1];
nums[0]=0;
for(int i=1;i<=n;i++){
nums[i]=sc.nextInt()+nums[i-1];
}
Deque<Integer> deque=new ArrayDeque<>();
deque.addFirst(0);
int ans= Integer.MIN_VALUE;
for(int i=1;i<=n;i++){
while(!deque.isEmpty()&&(i-deque.getFirst())>m) deque.removeFirst();
ans=Math.max(ans,nums[i]-nums[deque.getFirst()]);
while(!deque.isEmpty()&&nums[deque.getLast()]>nums[i]) deque.removeLast();
deque.addLast(i);
}
System.out.println(ans);
}
}
2.滑动窗口
题目描述
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。
示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
示例 2：
输入：nums = [1], k = 1
输出：[1]
提示：
1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length
题解：
用暴力作法，需要O(nk)的时间复杂度，为了优化降低时间复杂度，可以用单调队列遍历整个数组，找最小值时将前面比新加入的数大的数都删去，每次只取队头，可以将时间复杂度降低到O(n).
步骤：
①用一个数组来存储输入的数，用另一个数组存储每个元素在原数组中的下标。
②分为找最大值和找最小值两步来写。
注意事项：
①q数组存储的是原数组中的下标
②注意过程中一些变量的初始值为零，有的地方要加1
③注意什么时候用队头，什么时候用队尾
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
//记录窗口内最大值和其位置，每次移动后需要比较窗口内最大值和新值之间的关系
if(k==1) return nums;
int n=nums.length;
int[] res=new int[n-k+1];
//赋初值
Deque<Integer> deque=new ArrayDeque<>();
deque.addFirst(0);
for(int i=1;i<k;i++){
while(!deque.isEmpty()&&nums[deque.getLast()]<nums[i]){
deque.removeLast();
}
deque.addLast(i);
}
res[0]=nums[deque.getFirst()];
for(int i=1;i<n-k+1;i++){
while(!deque.isEmpty()&&(i>deque.getFirst())){
deque.removeFirst();
}
res[i]=Math.max(nums[deque.getFirst()],nums[i+k-1]);
while(!deque.isEmpty()&&(nums[i+k-1]>nums[deque.getLast()])){
deque.removeLast();
}
deque.addLast(i+k-1);
}
//如果i-deque.getFirst()>=3, 队首元素过期, 执行出队操作, deque.removeFirst();
//此时比较队首元素所在数组的值和
//单调递减队列，队列中存储数组下标，如果nums[i]>nums[deque.getLast()]那么deque队列尾部的元素j就要出队deque.removeLast()，因为j<i，并且nums[i]>nums[j],那么往后分析肯定用不到nums[j]。
//deque.addLast();
return res;
}
}
3. 烽火传递
题目描述
原题来自：NOIP 2010 提高组初赛 · 完善程序
烽火台是重要的军事防御设施，一般建在交通要道或险要处。一旦有军情发生，则白天用浓烟，晚上有火光传递军情。 在某两个城市之间有 n座烽火台，每个烽火台发出信号都有一定的代价。为了使情报准确传递，在连续 m 个烽火台中至少要有一个发出信号。现在输入n，m和每个烽火台的代价，请计算总共最少的代价在两城市之间来准确传递情报。
输入
第一行是 n,mn,m，表示 n 个烽火台和连续烽火台数 m；
第二行 nn 个整数表示每个烽火台的代价 ai。
输出
输出仅一个整数，表示最小代价。
样例输入
5 3
1 2 5 6 2
样例输出
4
提示
样例说明
在第 2,52,5 号烽火台上发信号。
题解：
单调队列维护dp
下面主要讲dp思想
设d p [ i ] dp[i]dp[i]表示从i个烽火台开始被点燃的花费最小值
则d p [ i ] = m i n ( d p [ i ] , d p [ j ] + a [ i ] ) ( i − m < = j < = i ) dp[i]=min(dp[i],dp[j]+a[i])(i-m<=j<=i)dp[i]=min(dp[i],dp[j]+a[i])(i−m<=j<=i)根据条件( i − m < = j < = i ) (i - m <= j <= i)(i−m<=j<=i)可知这是一个区间求单调递增队列问题
代码
public class Test {
public int test(int[] fees, int m) {
//fees={0,1,2,5,6,2}, m=3;
//记录窗口内最大值和其位置，每次移动后需要比较窗口内最大值和新值之间的关系
int n=fees.length;
if(m==1){
return Arrays.stream(fees).sum();
}
Deque<Integer> deque=new ArrayDeque<>();
int[] dp=new int[n];
dp[0]=fees[0];
deque.addFirst(0);
for(int i=1;i<n;i++){
while(!deque.isEmpty()&&(i-deque.getFirst()>m)) deque.removeFirst();
dp[i]=dp[deque.getFirst()]+fees[i];
while(!deque.isEmpty()&&deque.getLast()>fees[i]) deque.removeLast();
deque.addLast(i);
}
//两个城市之间有 n 座烽火台，每个烽火台发出信号都有一定的代价，为了使情报准确传递，在连续 m 个烽火台中至少要有一个发出信号。
// f [i] = min( f[j] ) + w[i] (i-m<=j<=i-1) f[i]表示前1-i座均满足要求，最后一座被点燃的是第i座
//用单调递增队列去维护f[j] (i-m<=j<=i-1)，每次取队首元素
//维护单调递增队列，首先去除f[j]且j<i-m的数据,然后更新f[i],最后维护单调递增去除队尾元素大于f[i]的,最后将f[i]入队尾
int ans=Integer.MAX_VALUE;
for(int i=n-m;i<n;i++){
ans=Math.min(dp[i],ans);
}
return ans;
}
}
