Problem
Description
一次小 G G G 和小 H H H 原本准备去聚餐，但由于太麻烦了于是题面简化如下：
一个转盘上有摆成一圈的 n n n 个物品（编号 1 1 1 至 n n n）其中第 i i i 个物品会在 T i T_i Ti 时刻出现。
在 0 0 0 时刻时,小 G G G 可以任选 n n n 个物品中的一个，我们将其编号记为 s 0 s_0 s0。并且如果 i i i 时刻选择了物品 s i s_i si，那么 i + 1 i + 1 i+1 时刻可以继续选择当前物品或者选择下一个物品。当 s i s_i si 为 n n n 时，下一个物品为物品 1 1 1，否则下一个物品为 s i + 1 s_{i} + 1 si+1。在每一时刻（包括 0 0 0 时刻），如果小 G G G 所选择的物品已经出现了，那么小 G G G 将会标记它。小 H H H 想知道，在物品选择的最优策略下，小 G G G 什么时候能标记所有物品？
但麻烦的是，物品的出现时间会不时修改。我们将其描述为 m m m 次修改，每次修改将改变其中一个物品的出现时间。每次修改之后，你也需要求出当前局面的答案。对于其中部分测试点，小 H H H 还追加了强制在线的要求。
Input Format
第一行三个非负整数 n , m , p n,m,p n,m,p，代表一共有 n n n 个物品， m m m 次修改。 p p p 只有 0 0 0 或 1 1 1 两种取值，强制在线时 p p p 为 1 1 1，否则为 0 0 0。本节后面将解释如何使用 p p p。
接下来一行，有 n n n 个用空格隔开的非负整数，第 i i i 个数 T i T_i Ti 代表物品 i i i 的出现时间。
接下来 m m m 行，每行两个非负整数 x , y x,y x,y，代表一次修改及询问。修改方式如下：
- 如果 p = 0 p = 0 p=0，则表示物品 x x x 的出现时间 T x T_x Tx 修改为 y y y。
- 如果 p = 1 p = 1 p=1，则先将 x x x 和 y y y 分别异或 L a s t A n s LastAns LastAns 得到 x ′ x′ x′ 和 y ′ y′ y′：即 x ′ = x ⊕ L a s t A n s , y ′ = y ⊕ L a s t A n s x′ = x \oplus LastAns, y′ = y \oplus LastAns x′=x⊕LastAns,y′=y⊕LastAns。然后将物品 x ′ x′ x′ 的出现时间 T x ′ T_{x′} Tx′ 修改为 y ′ y′ y′ 。其中的 L a s t A n s LastAns LastAns 是前一个询问的答案；特别的，第一次修改时的 L a s t A n s LastAns LastAns 为初始局面的答案。其中的 ⊕ \oplus ⊕ 为按位异或运算，例如 1 ⊕ 2 = 3 , 4 ⊕ 5 = 1 , 6 ⊕ 11 = 13 1 \oplus 2 = 3,4 \oplus 5 = 1,6 \oplus 11 = 13 1⊕2=3,4⊕5=1,6⊕11=13。
保证输入合法。
Output Format
第一行一个整数代表初始局面的答案。
接下来 m m m 行每行一个整数分别代表每次修改后的答案。
Sample
Input
5 3 0
1 2 3 4 5
3 5
5 0
1 4
Output
5
7
6
7
Range
| 测试点编号 | $n$ | $m$ | $T_i/T_x$ | $p$ |
|---|---|---|---|---|
| 1 | $\le 10$ | $=0$ | ||
| 2 | $\le 1000$ | $=0$ | $\le 1000$ | |
| 3 | $\le 10^5$ | $\le 10^5$ | ||
| 4 | $\le 5000$ | |||
| 5 | $\le 8\times 10^4$ | |||
| 6 | $=1$ | |||
| 7 | $\le 9\times 10^4$ | $=0$ | ||
| 8 | $=1$ | |||
| 9 | $\le 10^5$ | $=0$ | ||
| 10 | $=1$ | |||
Algorithm
线段树，单调栈
Mentality
这题真是毒瘤
.
.
.
.
.
.
......
...... (我觉得比毒瘤毒瘤)
我们先看看数据范围 . . . . . . ...... ...... n l o g n nlogn nlogn 预定。
先考虑一下小小地转化模型，因为要求的东西实在不好算。那么我们考虑把题目所述的过程倒过来看 . . . . . . ...... ...... 那就变成了在环上往前走，每个点都会在某一时刻消失，在每个点消失前遍历所有点。
在转化模型之后，我们肯定能得出一个结论：中途停下永远不会更优！
先破环为链来思考。
对于一个位置为起点，因为我们必须要走遍整个环所有点，我们只需要计算一下从当前点出发最少需要多少时间来确保能够安全到达每个点。
则不难想到，我们从点 i i i 出发，遍历 i ∼ i − n + 1 i\sim i-n+1 i∼i−n+1 所需要的最少时间肯定为：
M a x i − n + 1 < j ≤ i ( T [ j ] + i − j ) M a x i − n + 1 < j ≤ i ( T [ j ] − j ) + i Max_{i-n+1< j\le i}(T[j]+i-j)\\ Max_{i-n+1< j\le i}(T[j]-j)+i Maxi−n+1<j≤i(T[j]+i−j)Maxi−n+1<j≤i(T[j]−j)+i
即我们多出来的需要时间的最大值。
那对于一个局面，我们的答案为：
A n s = M i n n < i ≤ 2 ∗ n ( M a x i − n + 1 < j ≤ i ( T [ j ] − j ) + i ) Ans=Min_{n< i\le2*n}(Max_{i-n+1< j\le i}(T[j]-j)+i) Ans=Minn<i≤2∗n(Maxi−n+1<j≤i(T[j]−j)+i)
好的，我们已经能在 n l o g n nlogn nlogn 的时间内求出答案了！
然后继续转式子，用 i + ( n − 1 ) i+(n-1) i+(n−1) 来代替 i i i ，也就是把模型再转化回去：
A n s = M i n 1 ≤ i ≤ n ( M a x i ≤ j ≤ i + n − 1 ( T [ j ] − j ) + i ) + n − 1 Ans=Min_{1\le i\le n}(Max_{i\le j\le i+n-1}(T[j]-j)+i)+n-1 Ans=Min1≤i≤n(Maxi≤j≤i+n−1(T[j]−j)+i)+n−1
我们考虑将一个数组 n u m [ i ] = T [ i ] − i num[i]=T[i]-i num[i]=T[i]−i 代入：
A n s = M i n 1 ≤ i ≤ n ( M a x i ≤ j ≤ i + n − 1 n u m [ j ] + i ) + n − 1 Ans=Min_{1\le i\le n}(Max_{i\le j\le i+n-1}num[j]+i)+n-1 Ans=Min1≤i≤n(Maxi≤j≤i+n−1num[j]+i)+n−1
此时，我们可以扩大一下下标范围，因为 n u m [ i + n ] = T [ i ] − ( i + n ) ≤ n u m [ i ] = T [ i ] − i num[i+n]=T[i]-(i+n)\le num[i]=T[i]-i num[i+n]=T[i]−(i+n)≤num[i]=T[i]−i ，所以，我们不妨改大 M a x Max Max 的取值范围：
A n s = M i n 1 ≤ i ≤ n ( M a x i ≤ j ≤ 2 ∗ n n u m [ j ] + i ) + n − 1 Ans=Min_{1\le i\le n}(Max_{i\le j\le 2*n}num[j]+i)+n-1 Ans=Min1≤i≤n(Maxi≤j≤2∗nnum[j]+i)+n−1
由于此时范围已经到了序列末端，那么等价于我们对于每次枚举的 i i i ，答案肯定对应为：后缀最大值 + i + n − 1 +i+n-1 +i+n−1 。
表面看起来这并不会使复杂度变优，但是我们注意到一件事情，那就是对于某一段 i i i ，它们的后缀最大值肯定都是相等的，而对于某个后缀最大值，它对答案的最优贡献肯定是符合条件的，最小的那个 i i i 。
所以我们尝试一下考虑一个相对后缀最大值来讲的答案：
- n u m [ i ] num[i] num[i] 本身就是后缀最大值，向左找到第一个大于 n u m [ i ] num[i] num[i] 的位置 j j j ，则对于后缀最大值 n u m [ i ] num[i] num[i] 而言，它所能贡献的最优答案为 n u m [ i ] + j + 1 + n − 1 = n u m [ i ] + j + n num[i]+j+1+n-1=num[i]+j+n num[i]+j+1+n−1=num[i]+j+n 。
- n u m [ i ] num[i] num[i] 不是后缀最大值，那么它的最优答案等同于后缀最大值位置。
看起来是不是好搞一点了
这启发我们维护一个从后往前单调递增的序列，或者说单调栈，遇到大于栈顶的就压入栈，否则不作处理。
设单调栈内元素为 s t a c k 0 , s t a c k 1 . . . . . . s t a c k t o p stack_0,stack_1\ ......\ stack_{top} stack0,stack1 ...... stacktop 那么对于元素 s t a c k i stack_i stacki ，它的答案就是 n u m [ s t a c k i ] + s t a c k i + 1 + n num[stack_i]+stack_{i+1}+n num[stacki]+stacki+1+n ，我们只需要取栈内答案最小值即可。
那这个东西怎么维护呢？这就是一个神仙技巧了：线段树维护单调栈！
我也觉得这个东西挺仙的
首先考虑我们维护的是从后往前单调递增的一个栈，那么我们只需要注意合并即可。
合并过程如下 (可能挺难理解的)：
- 对于右区间，如果最大值大于当前栈内最大值，那么左区间相对当前答案就可以直接采用，然后递归处理右区间并加入当前区间
- 如果右区间最大值小于栈内最大值，递归处理左区间。
确实很难理解 = = 。我们需要维护如下信息：区间最大值，左子区间答案。然后递归统计即可。
而且我们其实不用维护 2 ∗ n 2*n 2∗n 这么长的区间，因为 n + 1 ∼ 2 ∗ n n+1\sim 2*n n+1∼2∗n 的最大值肯定为 1 ∼ n 1\sim n 1∼n 内最大值 − n -n −n 嘛，那么右子区间的栈内最大值就是左子区间最大值 − n -n −n 嘛！
其实代码异常的短，只有 a d d add add ， q u e r y query query ，和 p u s h u p pushup pushup 操作，建议配合代码及注释理解。
Code
#include<iostream>
#include<cstdio>
#define ls (o<<1)
#define rs ((o<<1)+1)
#define mid ((l+r)>>1)
using namespace std;
int n,m,p,a[100001];
int L,R,x,y,ans,maxx[400001],adv[400001];
int query(int o,int l,int r)
{
if(l==r)return maxx[o]>x?x+l:1e9;//x为栈内最大值，l自然就为答案计算式子中的 p(i+1)
return maxx[rs]>x?min(adv[o],query(rs,mid+1,r)):query(ls,l,mid);//判断左右子树最大值贡献
}
void pushup(int o,int l,int r)
{
maxx[o]=max(maxx[ls],maxx[rs]);//最大值合并
x=maxx[rs],adv[o]=query(ls,l,mid);//处理左子树答案
}
void add(int o,int l,int r)
{
if(l==r)
{
maxx[o]=a[l]-l;//赋值为 num 数组
return;
}
if(mid>=L)add(ls,l,mid);
if(mid<R)add(rs,mid+1,r);
pushup(o,l,r);
}
int main()
{
cin>>n>>m>>p;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
L=i,R=i;
add(1,1,n);
}//先建树
x=maxx[1]-n;
ans=query(1,1,n)+n;
printf("%d\n",ans);
while(m--)
{
scanf("%d%d",&y,&x);
y^=(ans*p),x^=(ans*p);
a[y]=x,L=y,R=y;
add(1,1,n);
x=maxx[1]-n;//n+1 - 2*n 最大值
printf("%d\n",ans=query(1,1,n)+n);//计算答案
}
}
扫一扫
308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
