Codeforces Round #291 (Div. 2) D. R2D2 and Droid Army RMQ/单调队列/尺取法
题意：M种detail的序列，求这样的区间：区间内每种detail的最大值之和不超过数值K，求区间的最大长度。
解法一：二分+区间最大值（RMQ或单调队列）
由于是求最大长度，而给定一个长度我们可去check是否为合法解，所以可以使用二分。
①区间最大值RMQ问题可以使用线段树、ST算法（sparse table）降低查询复杂度。线段树和ST算法预处理需要O（nlogn），线段树查询需要O(logn)，ST可以在O（1）时间内返回区间最大值。二者思路都是不断划分区间，线段树很熟悉了，所以回顾一下ST算法。ST算法用到了动态规划的思想，令dp[i][j]表示从i开始2^j个数内的最大值，则
dp[i][j] = max{dp[i-1][j-1]，dp[i+2^(j-1)][j-1]}
查询时，将区间(a,b)分成两个相交的区间，然后取这两个子区间的最大值即可。找到一个k，使得a+2^k-1≤ b-2^k+1，即：找到一个最小的k，使得2*2^k ≥ b-a，覆盖整个区间。则k=log(b-a)可以在O(1)时间内确定，查询结果为max{dp[a][k]，dp[b-2^k+1][k]}。
二分长度，然后枚举区间的起点判断最大值是否满足要求即可。
代码如下：
#include <cstdio>
#include <cmath>
using namespace std;
#define N 100005
#define M 31
#define max(a, b) (a) > (b) ? (a) : (b)
int dp[N][M][5], detail[N][5], res[5], n, m, k;
inline int query(int a, int b, int type){
int t = log((double)(b - a + 1))/ log(2.0);
return max(dp[a][t][type], dp[b - (1 << t) + 1][t][type]);
}
bool check(int len){
int bound = n - len, need[5];
for(int i = 0; i <= bound; ++i){
int j = i + len - 1, total = 0;
for(int s = 0; s < m; ++s){
need[s] = query(i, j, s);
total += need[s];
}
if(total <= k){
for(int s = 0; s < m; ++s)
res[s] = need[s];
return true;
}
}
return false;
}
int main(){
scanf("%d %d %d", &n, &m, &k);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j)
scanf("%d", &detail[i][j]);
}
for(int t = 0; t < m; ++t){
for(int i = 0; i < n; ++i)
dp[i][0][t] = detail[i][t];
for(int j = 1; j < M; ++j){
for(int i = 0; i < n; ++i){
int tmp = i + (1 << (j - 1));
if(tmp >= n)
break;
dp[i][j][t] = max(dp[i][j - 1][t], dp[tmp][j - 1][t]);
}
}
}
int l = 1, r = n;
while(l < r - 1){
int mid = l + ((r - l) >> 1);
if(check(mid))
l = mid;
else
r = mid - 1;
}
check(r);
for(int i = 0; i < m; ++i)
printf("%d ", res[i]);
printf("\n");
return 0;
}
②单调队列：给定区间长度，可以求出滑动窗口内的最大值，检查最大值是否满足即可。
代码如下：
#include <cstdio>
#include <cstring>
using namespace std;
#define N 100005
int n, m, k, a[N][5], res[5], shots[5], que[5][N], head[5], tail[5];
long long f[N];
bool check(int len){
memset(head, 0, sizeof(head));
memset(tail, 0, sizeof(tail));
memset(que, 0, sizeof(que));
memset(f, 0, sizeof(f));
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){ //[head, tail)前闭后开区间,注意队列非空条件和队尾的访问
while(tail[j] > head[j] && a[que[j][tail[j] - 1]][j] <= a[i][j])
--tail[j];
que[j][tail[j] ++] = i;
while(que[j][head[j]] < i - len + 1)
++head[j];
if(i >= len - 1)
shots[j] = a[que[j][head[j]]][j], f[i] += shots[j] ;
}
if(i >= len - 1 && f[i] <= (long long)k){
for(int j = 0; j < m; ++j)
res[j] = shots[j];
return true;
}
}
return false;
}
int main(){
scanf("%d %d %d", &n, &m, &k);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j)
scanf("%d", &a[i][j]);
}
int l = 1, r = n;
while(l < r - 1){
int mid = l + ((r - l) >> 1);
if(check(mid))
l = mid;
else
r = mid - 1;
}
check(r);
for(int i = 0; i < m; ++i)
printf("%d ", res[i]);
return 0;
}
③尺取法+队列优化：假设从
开始，到
才不满足
，则从
开始，若到
才不满足条件，必有t≤t'。所以可以使用尺取法。具体做法为：开始时首尾指针均指向第一个元素，以后对当前区间，若m种detail满足最大值之和≤k，则更新区间长度；否则将首指针后移。由于尾指针从0变化到n，故复杂度为o(nm)。
队列优化借鉴了一下别人的做法：用一个辅助队列来完成非最优值的出队。该队列记录当前需要出队的元素，当该元素成为当前区间的最大值时，才真正将它pop出去。理由是：随着窗口的移动，若左端点a[l]＜max，则max值仍在区间内部仍然有用，a[l]在队列中也不影响。而当a[l]成为队列中最大值时，会对正确值产生干扰，所以此时是a[l]出队的最好时机。
代码如下：
#include <cstdio>
#include <queue>
using namespace std;
#define N 100005
#define M 5
#define max(a, b) (a) > (b) ? (a) : (b)
int a[N][M], res[M], need[M];
priority_queue<int> qu[M], topop[M];
int main(){
int n, m, k, ans = 0;
scanf("%d %d %d", &n, &m, &k);
for(int i = 0; i < n; ++i)
for(int j = 0; j < m; ++j)
scanf("%d", &a[i][j]);
int s = 0, t = 0;
for(;t < n; ++t){
long long sum = 0;
for(int i = 0; i < m; ++i)
qu[i].push(a[t][i]);
for(int i = 0; i < m; ++i)
need[i] = qu[i].top(), sum += need[i];
if(sum <= k){
if(ans < t - s + 1){
ans = t - s + 1;
for(int i = 0; i < m; ++i)
res[i] = need[i];
}
}
else{
for(int i = 0; i < m; ++i){
topop[i].push(a[s][i]);
while(!topop[i].empty() && !qu[i].empty() && topop[i].top() == qu[i].top())
topop[i].pop(), qu[i].pop();
}
++s;
}
}
for(int i = 0; i < m; ++i)
printf("%d ", res[i]);
return 0;
}