NEERC 2012 Moscow Subregional D Darkwing Duck : 区间最大后缀：单调栈

从叉姐姐那里学到的棒棒题~

题意：

给一个串，区间询问字典序最大后缀。可以离线。$n,q\le 5\cdot 10^5$
题目链接

题解:

在线做法还没看懂，留坑。

离线做法是这样的：

首先去掉这个题的字符串背景，单纯考虑求区间最大值，有一种离线单调栈的做法：
从左到右扫，维护一个单减的单调栈，然后每次处理掉所有$r=i$的询问，只需要在单调栈里二分$l$就行了。

本题使用上面的想法，做了一点点显然的修改：

用一个单减单调栈维护完整后缀，当有一个新后缀$S[i,n]$加入时，如果栈顶后缀$S[stk.top(),n]$小，就把他弹出去。然后把新后缀$S[i,n]$压入栈里。

这样做会有一个问题：栈顶的那个完整后缀是小的， 但是现在只考虑到$S[1,i]$的时候，它可以是大的，因此他还要苟活一阵子，也就是苟活到$i+lcp(stk.top(),i)$这一时刻彻底被杀死。

因此我们对每个时刻开一个vector，保存谁到这个时刻要被杀掉，然后用一个set维护现在还活着的后缀点。

这里还有一个细节要讲一下：可能存在这样一种情况，当某个$i$的时候，我们决定了前边的某个$j<i$需要在$DL$时刻死掉，但是可能在算法后续的状态中，还没有到$DL$时刻，$i$死掉了，但是还没到$DL$时刻，$j$还苟活在我们的$set$里边，这样这个$set$的状态就不对了。

但是这是矛盾的，因为如果存在这种情况，$j$在对称的之前的那个时刻就死掉了。

求lcp直接二分hash就行了，不影响复杂度。复杂度$O((n+Q)\cdot \log n)$

#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ULL;
const ULL Base = 146527;
const ULL Mod = 1e9 + 9;
const int maxn = 5e5 + 100;
char s[maxn];
int n,q,ans[maxn];
vector<tuple<int,int,int> >Q;
vector<int> E[maxn];
ULL base[maxn],sum[maxn];
void init_hash(){
    base[0] = 1;
    for (int i=1;i<=n;i++){
        base[i] = base[i-1] * Base % Mod;
        sum[i] = (sum[i-1] * Base % Mod + s[i]) % Mod;
    }
}
inline ULL get_hash(int l,int r){
    return (sum[r] - sum[l-1] * base[r - l + 1] % Mod + Mod) % Mod;
}
int get_lcp(int x,int y){
    int l = 0, r = n - max(x,y) + 1;
    while (r-l > 1){
        int mid = l + r >> 1;
        if (get_hash(x,x + mid - 1) == get_hash(y,y + mid - 1))l = mid;
        else r = mid;
    }
    for (int ans = r;ans >= l;ans --)if (get_hash(x,x + ans - 1) == get_hash(y,y + ans - 1))return ans;
    assert(0);
}
int main(){
    scanf("%s",s+1);n = strlen(s+1);
    s[n+1] = CHAR_MAX;
    init_hash();
    scanf("%d",&q);
    for (int i = 1;i <= q;i ++){
        int l,r;scanf("%d%d",&l,&r);
        Q.push_back(make_tuple(l,r,i));
    }
    sort(Q.begin(),Q.end(),[](tuple<int,int,int> x,tuple<int,int,int> y){
        return get<1>(x) > get<1>(y);
    });
    stack<int> stk;set<int> st;
    for (int i=1;i<=n;i++){
        while (!stk.empty()){
            int lcp = get_lcp(stk.top(),i);
            if (s[i + lcp] > s[stk.top() + lcp]){
                E[i + lcp].push_back(stk.top());
                stk.pop();
            }else break;
        }
        stk.push(i);st.insert(i);
        for (auto x : E[i])st.erase(x);
        while (!Q.empty() and get<1>(Q.back()) == i){
            ans[get<2>(Q.back())] = *st.lower_bound(get<0>(Q.back()));
            Q.pop_back();
        }
    }
    for (int i=1;i<=q;i++)printf("%d\n",ans[i]);
    return 0;
}