7.21多校——5289RMQ_st + 二分搜索 + 单调队列——Assignment

roblem Description

Tom owns a company and he is the boss. There are n staffs which are numbered from 1 to n in this company, and every staff has a ability. Now, Tom is going to assign a special task to some staffs who were in the same group. In a group, the difference of the ability of any two staff is less than k, and their numbers are continuous. Tom want to know the number of groups like this.

 

 

Input

In the first line a number T indicates the number of test cases. Then for each case the first line contain 2 numbers n, k (1<=n<=100000, 0<k<=10^9),indicate the company has n persons, k means the maximum difference between abilities of staff in a group is less than k. The second line contains n integers:a[1],a[2],…,a[n](0<=a[i]<=10^9),indicate the i-th staff’s ability.

 

 

Output

For each test，output the number of groups.

 

 

Sample Input

2 4 2 3 1 2 4 10 5 0 3 4 5 2 1 6 7 8 9

 

 

Sample Output

5 28

Hint

First Sample, the satisfied groups include:[1,1]、[2,2]、[3,3]、[4,4] 、[2,3]

 

 

Author

FZUACM

 

 

Source

2015 Multi-University Training Contest 1

 

 

Recommend

We have carefully selected several similar problems for you:   5299  5298  5297  5296  5295 

牛人博客 http://www.cnblogs.com/silence250627170/archive/2011/07/24/2115692.html

/*
题意：

RMQ_st算法
复杂度：预处理nlogn 查询O(1)
实现：
用DP的思想
mx[i][j] 定义为以i为起点长度为1<<j的区间内的最大值
状态转移方程 mx[i][j] = mx[i][j-1] + mx[i+(1<<(j-1))][j-1] 
把区间分成长度为1<<(j-1)的两个部分
总共处理的长度从1到log2(n),起点从1到n
所以总复杂度O(nlogn)

二分搜索位置
假定了l到r之间必定有一段
二分搜索从i到n，得到以该点开始能到右边最多多少
如果i到mid可以说明二分区域在另一块，另l = mid
因为有RMQ的存在能得到该区间是否满足，二分对于数列需单调的要求就是因为要使得端点为极值

*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

const int MAX = 100000 + 10;
int mx[MAX][20], mn[MAX][20];
int a[MAX]; 
int n;
void  rmq()
{
    for(int i = 1; i <= n; i++)
        mx[i][0] = mn[i][0] = a[i];
        int m = log2(n*1.0);
        for(int i = 1; i <= m; i++){
            for(int j = 1;j <= n; j++){
                if(j + (1 << (i - 1)) <= n)
                    mx[j][i] = max(mx[j][i-1], mx[j + (1 << (i - 1))][i - 1]);
                    mn[j][i] = min(mn[j][i-1], mn[j + (1 << (i - 1))][i - 1]);
                }
            }
}

int rmqmin(int l, int r)
{
    int m = log2(1.0*(r - l + 1));
    return min(mn[l][m], mn[r - (1 << m) + 1][m]);
}

int rmqmax(int l, int r)
{
    int m = log2(1.0*(r - l + 1));
    return max(mx[l][m], mx[r - (1 << m) + 1][m]);
}

int cal(int l, int r)
{
    return rmqmax(l, r) - rmqmin(l, r);
}

int main()
{
    int T, k;
    scanf("%d", &T);
    while(T--){
        long long  ans = 0;
        scanf("%d%d", &n, &k);
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        rmq();
       // printf("%d %d\n",rmqmax(2, 2),rmqmin(1,5));
        int l, r, mid;
        for(int i = 1; i <= n; i++){
            l = i, r = n;
            while(l + 1 < r){
                 mid = (l + r) >> 1;
                if(cal(i, mid) < k)
                    l = mid;
                else r = mid;
            }
            if(cal(i, r) < k)
                ans = ans + (long long )(r - i + 1);
            else{
               ans = ans + (long long )(l - i + 1);
            }
        }
       printf("%lld\n", ans);
    }
    return 0;
}

            
        

/*
单调队列(双端队列做法)
deque    
deque q
主要用的库函数 
q.pop_back():删去最后的值
q.push_back():把当前数入队到最后
q.pop_front():删去最前面的值
q.front():得到最前面的值
q.back():得到最后面的值
单调队列维护最小最大值在队列里面保存的是下标，不过也可以开结构体把两个都保存下来
假设我们现在维护最大值:
假定j为队列最后值的下标，i为当前需要入队的下标（下标指的是原数组中所在的位置）
if(a[j] < a[i]) 那么最大值是j-1前面的数或者当前这个i，直接q.back()删去当前的a[j]
直到能插入，处理结束后最前面的的值q.front为1到i里面最大的值的下标

对于每一个数我们找最往左的位置，不断更新下标
每一个数入队出队次数就一次
所以复杂度为O(c*n) = O(n)
*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int MAX = 1e5 + 10;
struct edge{
    int n, id;
};
deque<edge> Q1, Q2;
int a[MAX];

int main()
{
    int T;
    int n, k;
    scanf("%d", &T);
    while(T--){
            Q1.clear();
            Q2.clear();
        long long ans = 0;
        scanf("%d%d", &n, &k);
        for(int i = 1; i <= n ;i++)
            scanf("%d", &a[i]);
        int head = 1;
        for(int i = 1; i <= n ; i++){
            edge now = (edge){a[i], i};
            while(!Q1.empty()){
                edge temp = Q1.back();
                if(now.n > temp.n) Q1.pop_back();//得到max
                else break;
            }
            Q1.push_back(now);

            while(!Q2.empty()){
                edge temp = Q2.back();
                if(now.n < temp.n) Q2.pop_back();//得到min
                else break;
            }
            Q2.push_back(now);
           if(i == 1) ans++;
           else {
               while(1){
                   edge big = Q1.front();
                   edge small = Q2.front();
                   if(big.n - small.n < k) break;
                   else {
                       if(small.id < big.id){
                            head = small.id + 1;
                            Q2.pop_front();
                       }
                       else {
                           head = big.id + 1;
                           Q1.pop_front();
                       }
                   }
               }
           ans += i - head + 1;
           }
       }
        printf("%lld\n", ans);
    }
    return 0;
}
          

　　

转载于:https://www.cnblogs.com/zero-begin/p/4667671.html