[HNOIAHOI2018] 转盘（线段树维护单调栈）

problem

洛谷链接

solution

结论：最优方案中一定有一种是全程不停的。

断环成链，接一个 $[1,n]$ 在后面形成 $2n$ 的序列，同时将时间戳逆过来。

转化成：在 $t$ 时刻从某个位置 $i\in [n,2n)$ 开始往前取物品，时刻 $-1$，物品 $j$ 在 $t_j$ 时刻消失，要求标记所有的物品。最小化这个 $t$。

$t$ 时刻开始从 $i$ 位置到物品 $j$，需要 $i-j$ 的时间，即 ${\forall }_{j\in (i-n,i]}t-(i-j)\ge T_j$。

显然全程不停歇是更好的。

t − ( i − j ) ≥ t j ⇒ t ≥ t j − j + i , j ∈ ( i − n , i ] ⇒ t min ⁡ = max ⁡ { t j − j } + i , j ∈ ( i − n , i ] t-(i-j)\ge t_j\Rightarrow t\ge t_j-j+i,j\in(i-n,i]\Rightarrow t_{\min}=\max\{t_j-j\}+i,j\in(i-n,i] t−(i−j)≥tj​⇒t≥tj​−j+i,j∈(i−n,i]⇒tmin​=max{tj​−j}+i,j∈(i−n,i]。

考虑枚举 $i\in [n,2n)$，算出 $[i]t_{\min }$ 整体取 $\min$ 才是最终答案，每个 $i$ 的计算都要 $n\log n$。

令 $a_i=T_i-i$，则 a n s = min ⁡ n ≤ i < 2 n { max ⁡ i − n < j ≤ i { a j } + i } ans=\min_{n\le i< 2n}\big\{\max_{i-n<j\le i}\{a_j\}+i\big\} ans=minn≤i<2n​{maxi−n<j≤i​{aj​}+i}。

用 $i$ 替换 $i+n-1$，有 a n s = min ⁡ 1 ≤ i ≤ n { max ⁡ i ≤ j ≤ i + n − 1 { a j } + i } + n − 1 ans=\min_{1\le i\le n}\big\{\max_{i\le j\le i+n-1}\{a_j\}+i\big\}+n-1 ans=min1≤i≤n​{maxi≤j≤i+n−1​{aj​}+i}+n−1。

因为 $a_i=T_i-i>a_{i+n}=T_i-(i+n)$，所以稍微扩大 $j$ 范围对答案无影响。

即 a n s = min ⁡ 1 ≤ i ≤ n { max ⁡ i ≤ j ≤ 2 n { a j } + i } + n − 1 ans=\min_{1\le i\le n}\big\{\max_{i\le j\le 2n}\{a_j\}+i\big\}+n-1 ans=min1≤i≤n​{maxi≤j≤2n​{aj​}+i}+n−1。

对 $i$ 处理一个后缀最大值就能得到答案，到此也只是扔了个 $log$ 并没起到多大优化，$O(nm)$ 仍无法接受。

$i$ 不行转过来考虑 $j$，考虑每个 $j$ 的答案是怎样的。（特别地，$a_0=inf$）

• 如果 $j$ 是后缀最大值点。

  对于 $j$，往前找到第一个 $a_k>a_j$ 的 $k$，$i\in (k,n]$ 都是 $j$ 处取 $\max$，当 $i=k+1$ 时才满足外层的 $\min$ 操作，因此 $j$ 的贡献应为 $a_j+k+1$。

  由 $i$ 的限制可以反推得到 $k<n$。

• 如果 $j$ 不是，那答案仍是后面某个点产生的。

• 最后就是这些 $j$ 贡献取 $\min$。

基于这样的分类，发现可以从后往前维护 $a_j$ 的一个单调递增栈。

假设单调栈内的元素为 $s_0=0<s_1<...<s_x$。

$ans={\min }_{1\le i\le x}\{a_{s_i}+s_{i-1}+1\}+n-1={\min }_{1\le i\le x}\{a_{s_i}+s_{i-1}\}+n$，要求 $s_{i-1}<n$。

用线段树来维护单调栈楼房重建，具体合并两个区间单调栈。

• 右子树答案直接拿。
• 用右子树最大值在做子树内找到最靠近右子树的第一个比其大的位置返回。
• 对该位置前面的取整体最小值。

最优位置 $j$ 要满足 $s_{j-1}<n$ 所以要记录这个询问的结果位置。

但最终答案实际上就是 $i\in (n,2n]$ 的最大值在 $[1,n]$ 里面二分找 $j$ 执行上述流程中得到的。

看似是维护 $a_i(1\le i\le 2n)$ 的最大值，事实上 $i\in [n,2n)$ 的最大值 $a_i=T_i-i$，就等于 $i-n\in [1,n)$ 的最大值 $a_{i-n}=T_{i-n}-(i-n)=T_i-i+n$ 减去 $n$。

所以线段树只需要维护 $[1,n]$ 的最大值信息即可，再在 $[1,n]$ 里面查。

时间复杂度 $O((n+Q)\log n^2)$。

code

#include <bits/stdc++.h>
using namespace std;
#define inf 0x7f7f7f7f
#define maxn 100005
int n, m, p;
int t[maxn], Max[maxn << 2], Ans[maxn << 2];

#define lson now << 1
#define rson now << 1 | 1
#define mid (l + r >> 1)

int query( int now, int l, int r, int x ) {
    if( l == r ) return Max[now] > x ? x + l : inf;
    if( Max[rson] <= x ) return query( lson, l, mid, x );
    else return min( Ans[now], query( rson, mid + 1, r, x ) );
}

void pushup( int now, int l, int r ) {
    Max[now] = max( Max[lson], Max[rson] );
    Ans[now] = query( lson, l, mid, Max[rson] );
}

void build( int now, int l, int r ) {
    if( l == r ) { Max[now] = t[l] - l; return; }
    build( lson, l, mid );
    build( rson, mid + 1, r );
    pushup( now, l, r );
}

void modify( int now, int l, int r, int pos ) {
    if( l == r ) { Max[now] = t[pos] - pos; return; }
    if( pos <= mid ) modify( lson, l, mid, pos );
    else modify( rson, mid + 1, r, pos );
    pushup( now, l, r );
}

int main() {
    scanf( "%d %d %d", &n, &m, &p );
    for( int i = 1;i <= n;i ++ ) scanf( "%d", &t[i] );
    build( 1, 1, n );
    int ans = query( 1, 1, n, Max[1] - n ) + n;
    printf( "%d\n", ans );
    while( m -- ) {
        int x, y;
        scanf( "%d %d", &x, &y );
        if( p ) x ^= ans, y ^= ans;
        t[x] = y, modify( 1, 1, n, x );
        ans = query( 1, 1, n, Max[1] - n ) + n;
        printf( "%d\n", ans );
    }
    return 0;
}