多校第三场第一题：Problem A. Ascending Rating

最新推荐文章于 2025-04-24 20:39:26 发布

P1n9

最新推荐文章于 2025-04-24 20:39:26 发布

阅读量487

点赞数

分类专栏： # ACM__数据结构

本文链接：https://blog.youkuaiyun.com/qq_36386435/article/details/81292840

版权

ACM__数据结构专栏收录该内容

6 篇文章

订阅专栏

Problem A. Ascending Rating
Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 524288/524288 K (Java/Others)
Total Submission(s): 1339 Accepted Submission(s): 362

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

这道题靠的是数据结构，没有接触过这样的类型题，所以思考很困难，有的时候正向思维比较难想，反过来想就好弄多了
题解：
按照 r 从 m 到 n 的顺序很难解决这个问题。
考虑按照 r 从 n 到 m 的顺序倒着求出每个区间的答案。
按照滑窗最大值的经典方法维护 a 的单调队列，那么队列中的元素个数就是最大值的变化次数
O(n)的复杂度解决

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int maxn=1e7+5;
typedef struct Node{
    int value,pos;
    Node(){}
    Node(int v,int p){value = v;pos = p;}
}Node;
int a[maxn];
Node node[maxn];
LL A,B;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m,k,p,q,r,mod;
        scanf("%d %d %d %d %d %d %d",&n,&m,&k,&p,&q,&r,&mod);
        A = 0;
        B = 0;
        for(int i = 1;i <= k;++i)
        {
            scanf("%d",&a[i]);
        }
        for(int i = k + 1;i <= n;++i)
        {
            a[i] = (1LL * p * a[i - 1] + 1LL * q * i + r) % mod;
        }
        int head = 1,tail = 0;
        for(int i = n;i >= 1;--i)
        {
            //删尾
            while(head <= tail && node[tail].value <= a[i]) tail--;
            //得到最优解并插入
            node[++tail] = Node(a[i],i);
            //去头
            while(node[head].pos - i >= m) head++;
            if(i <= n - m + 1){
                //printf("%d %d %d\n",node[head].value,tail - head + 1,index);
                A += (LL)(node[head].value ^ i);
                B += (LL)((tail - head + 1) ^ i);
            }
        }
        printf("%lld %lld\n",A,B);
    }
    return 0;
}

转载：https://blog.youkuaiyun.com/a_bright_ch/article/details/77076228
单调队列的介绍与使用：
单调队列顾名思义就是一个有规律的队列，这个队列的规律是：所有在队列里的数都必须按递增（或递减）的顺序列队，如果真有这么一个队列，那么队列的头是不是就是最小（或最大）的呢？

可以解决区间段内的最大值

例题：（来源：caioj 1172）

给定一个n个数的数列，从左至右输出每个长度为m的数列段内的最大数。

解法1：
如果按照常规方法，我们在求f[i]即i~i+m-1区间内的最值时，要把区间内的所有数都访问一遍，时间复杂度约为O（nm）。有没有一个快一点的算法呢？

解法2：
我们知道，上一种算法有一个地方是重复比较了，就是在找当前的f(i)的时候，i的前面k-1个数其它在算f(i-1)的时候我们就比较过了。那么我们能不能保存上一次的结果呢？当然主要是i的前k-1个数中的最大值了。答案是可以，这就要用到单调递减队列。

使用单调队列就涉及到去头和删尾：

1、队列的头一定是在一段时间前就加入了队列，现在的队列头会不会离开了我们处理的区间呢？如果它离我们正在处理的i太远了，我们就要把它去掉，去除冗杂的信息。

2、为了保证队列的递减性，在从列队尾新插入元素v时，要考虑队列尾的值是否大于v，如果是，队列呈现队列尾-1的值 > 队列尾的值 > v ，此时队列递减性没有消失；如果不是，队列呈现队列尾-1的值 > 队列尾的值 < v ，队列递减性被打破。

为了维护递减性，我们做如下考虑：v是最新值，它的位置是目前最靠后的，它可成为以后的最大值，必须留下；队列尾-1的值与v大小不定，不能冒然删去它；队列尾的值夹在v和队列尾-1之间，它不但不是最大值，对于以后的情况又不如v优，因为v相比队列尾更靠后（v可以影响到后m个值，队列尾只能影响到从它的位置往后数m-1个值），而且值更大，所以删队列尾是必定的。

在维护好一个区间正确、严格递减的单调递减队列后，队列头就是当前区间的最大值了。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int a[200000];
struct node
{
    int x,p;
    node(){}
    node(int xx,int pp){x=xx;p=pp;}
}list[200000];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    int head=1,tail=1;
    list[1]=node(a[1],1);
    for(int i=2;i<=n;i++)
    {
        while(head<=tail&&list[tail].x<=a[i]) tail--;//删尾
        list[++tail]=node(a[i],i);//得到最优解并插入
        while(i-list[head].p>=m) head++;//去头
        if(i>=m) printf("%d\n",list[head]);
    }
    return 0;
}