HDU 6319 Ascending Rating

Problem Description

Before the start of contest, there are n ICPC contestants waiting in a long queue. They are labeled by 1 to n from left to right. It can be easily found that the i-th contestant's QodeForces rating is ai.
Little Q, the coach of Quailty Normal University, is bored to just watch them waiting in the queue. He starts to compare the rating of the contestants. He will pick a continous interval with length m, say [l,l+m−1], and then inspect each contestant from left to right. Initially, he will write down two numbers maxrating=0 and count=0. Everytime he meets a contestant k with strictly higher rating than maxrating, he will change maxrating to ak and count to count+1.
Little T is also a coach waiting for the contest. He knows Little Q is not good at counting, so he is wondering what are the correct final value of maxrating and count. Please write a program to figure out the answer.

Input

The first line of the input contains an integer T(1≤T≤2000), denoting the number of test cases.
In each test case, there are 7 integers n,m,k,p,q,r,MOD(1≤m,k≤n≤107,5≤p,q,r,MOD≤109) in the first line, denoting the number of contestants, the length of interval, and the parameters k,p,q,r,MOD.
In the next line, there are k integers a1,a2,...,ak(0≤ai≤109), denoting the rating of the first k contestants.
To reduce the large input, we will use the following generator. The numbers p,q,r and MOD are given initially. The values ai(k<i≤n) are then produced as follows :

ai=(p×ai−1+q×i+r)modMOD
It is guaranteed that ∑n≤7×107 and ∑k≤2×106.

 

Output

Since the output file may be very large, let's denote maxratingi and counti as the result of interval [i,i+m−1].
For each test case, you need to print a single line containing two integers A and B, where :

AB==∑i=1n−m+1(maxratingi⊕i)∑i=1n−m+1(counti⊕i)

Note that ``⊕'' denotes binary XOR operation.

Sample Input

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

Sample Output

46 11

Source

2018 Multi-University Training Contest 3

 

思路：zls的思路，从后面开始选取区间利用双向队列维护队列内严格递增的数目和最大值，巧妙！做题时这题始终只停留在构思上，没有想到从后面开始选区间，我一直是从前面开始想，没次头尾变化的时候对cnt和max值修改，但一直不知道如何处理，比如 9-2-3-4-10，当9从区间内出去时，后面2，3，4，10会形成一个新的递增序列，这就要记录2到10之间的递增序列。。。。。完全没想法，后面也没想去变通，如果从后往前处理，就可以解决这种问题，左边新的数来的时候只要把队列前方比自己小的数踢出去就行了，唉，做题的时候也不是很积极，反思反思。

 

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1e7+5;
int n,m,k,p,q,r,mod;
int a[maxn];
int pre[maxn];
int nxt[maxn];///双向队列

int read(){
    char c=getchar();
    while(c!='-'&&(c>'9'||c<'0')){
        c=getchar();
    }
    bool flag=0;
    if(c=='-') {
        flag=1;
        c=getchar();
    }
    int num=0;
    while(c>='0'&&c<='9'){
        num=num*10+c-'0';
        c=getchar();
    }
    if(flag) num=-num;
    return num;
}

void geta(){
    for(int i=k+1;i<=n;i++) a[i]=(p*1ll*a[i-1]+q*1ll*i+r)%mod;
}

int main(){
    int T=read();
    while(T--){
        n=read();m=read();k=read();p=read();q=read();r=read();mod=read();
        for(int i=1;i<=k;i++) a[i]=read();
        geta();
        long long A,B;
        A=B=0;
        nxt[n]=-1;
        pre[0]=-1;

        int cnt=1;
        int head=n;
        int tail=n;
        pre[n]=-1;

        for(int i=n-1;i>n-m+1;i--){///从后往前处理，妙啊妙
            while(head!=-1&&a[head]<=a[i]){///如果不小于头节点的值，队首出队
                head=nxt[head];
                cnt--;
            }
            if(head==-1) {///如果队列为空,i为尾，next的值为-1；
                nxt[i]=-1;
                tail=i;
            }
            else {///否则直接接上
                nxt[i]=head;
                pre[head]=i;
            }
            cnt++;
            head=i;///i为新队首
            //printf("%d %d\n",tail,head);
        }

        for(int i=n-m+1;i;i--){///队内维护一个严格递增的序列
            while(head!=-1&&a[head]<=a[i]){
                head=nxt[head];
                cnt--;
            }
            if(head==-1){
                tail=i;
                nxt[i]=-1;
            }
            else {
                nxt[i]=head;
                pre[head]=i;
            }
            cnt++;
            head=i;
            int r=i+m-1;///如果队尾的位置大于当前区间最后位置，出队
            while(tail>r){
                tail=pre[tail];
                nxt[tail]=-1;
                cnt--;
            }
            A+=(a[tail]^i);
            B+=(i^cnt);
        }
        printf("%lld %lld\n",A,B);
    }
}