ST表 = 单调栈 + 并查集优化 || P1198 [JSOI2008] 最大数

其实这个题不能算是ST表吧，可以算是一个初等数据结构题，有很多做法。

 

 

 

做法一：用反向ST表做，因为每次操作都是暴力在数组末尾加数，所以ST表可以实现O(logn)的插入（具体反向思想我还没搞懂，搞懂了回来补）。

代码 ：

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
//using i64 = long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";

const int N = 200010;
int f[N][21], lg[N], a[N];
int T;
void change(int u) {
    f[u][0] = a[u];
    for (int i = 1;u - (1 << i) >= 0;i ++) 
        f[u][i] = max(f[u][i - 1], f[u - (1 << (i - 1))][i - 1]);
}
long long find(int l, int r) {
    int k = lg[r - l + 1];
    //cout << "ZZZ" << ' ' << l << ' ' << r << ' ' << k << endl;
    //cout << "SSS" << ' ' << f[l][k] << ' ' << f[r - (1 << k) + 1][k] << endl;
    //return max(f[l][k], f[r - (1 << k) + 1][k]);
    return max(f[r][k],f[l + (1 << k) - 1][k]);
}

int main() {
    int n, mod;
    cin >> n >> mod;
    lg[1] = 0;
    for (int i = 2;i <= n;i ++)
        lg[i] = lg[i >> 1] + 1;
    int idx = 0;
    for (int i = 1;i <= n;i ++) {
        char o;
        cin >> o;
        if (o == 'A') {
            int x;
            cin >> x;
            x = (x + T) % mod;
            a[++idx] = x;
            change(idx);
        } else {
            int k;
            cin >> k;
            if (k == 1) {
                T = a[idx];
                cout << a[idx] << '\n';
            }
            else {
                T = find(idx - k + 1, idx);
                cout << T << '\n';
            }
        }
    }
}

做法二：可以用一个单调栈维护一下坐标。一开始想到了做法但是没找到单调性，其实是有单调性的因为如果新插入的数字要比栈顶所有元素大那么栈顶这个元素就没有贡献了（有单调性的重要原因是这个题查询是只查询后几个元素而不是随机区间，也就是说后面如果有比当前位置大的数那么当前位置的数一定没有贡献），所以用一个单调递减的单调栈维护。并且此时查询的时候也可以二分一下（查询栈中第一个大于等于查询数字的坐标），总体时间复杂度也是O(nlogn)的。

代码 ：

#include <algorithm>
#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
//using i64 = long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";

const int N = 200010;
int stk[N], tt, a[N], T;
int main() {
    int n, p;
    cin >> n >> p;
    int idx = 0;
    tt = T = 0;
    for (int i = 0;i < n;i ++) {
        char o;
        cin >> o;
        if (o == 'A') {
            int x;
            cin >> x;
            a[++ idx] = (x + T) % p;
            while (tt && a[idx] > a[stk[tt]]) tt --;
            stk[++tt] = idx;
        } else {
            int l;
            cin >> l;
            int ans = a[*lower_bound(stk + 1, stk + 1 + tt, idx - l + 1)];
            T = ans;
            cout << ans << '\n';
        }
    }
}

做法二小优化 ：可以在查询的时候用并查集优化二分。在元素出栈的时候可以发现当前元素的贡献应该归属于将它弹出元素的贡献，也就是说查询当前位置元素时候相当于查询它归属元素的贡献，那么就可以在这个元素出栈的时候将它与将它弹出的元素合并，并且以将它弹出的元素作为父亲，这样查询的时候就是查询当前元素所属于集合的代表元。那么并查集按秩合并后查询约等于线性的，但是在模拟维护单调栈的时候会有一个常数？（我自己认为的因为维护单调栈每个元素会进出一次，外面还挂着一个O(n)，应该也是O(n)但是会有一点点不同？），所以可能应该是平均情况O(n)，最坏应该能卡到O(logn)，不过这个题数据还是比较小的，看一下优化后的情况 :

 

可以看到优化了100ms左右，看来是几乎线性了我觉得。

做法都来源于luogu评论区，这个单调栈的做法基本能搞出来但是一开始没找到线性的就回去搞ST表了。。。。

代码 ：

 

#include <algorithm>
#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
//using i64 = long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";

const int N = 200010;
int stk[N], tt, a[N], T;
int p[N];
int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int main() {
    int n, m;
    cin >> n >> m;
    int idx = 0;
    tt = T = 0;
    for (int i = 0;i < n;i ++) {
        char o;
        cin >> o;
        if (o == 'A') {
            int x;
            cin >> x;
            a[++ idx] = (x + T) % m;
            p[idx] = idx;
            while (tt && a[idx] > a[stk[tt]]) p[find(stk[tt --])] = find(idx);
            stk[++tt] = idx;
        } else {
            int l;
            cin >> l;
            //int ans = a[*lower_bound(stk + 1, stk + 1 + tt, idx - l + 1)];
            int ans = a[find(idx - l + 1)];
            T = ans;
            cout << ans << '\n';
        }
    }
}