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;
}