[luogu3246][bzoj4540][HNOI2016]序列【莫队+单调栈】

题目描述

给定长度为n的序列：a1,a2,...,an，记为a[1:n]。类似地，a[l:r]（1<=l<=r<=N）是指序列：al,al+1,...,ar-1,ar。若1<=l<=s<=t<=r<=n，则称a[s:t]是a[l:r]的子序列。现在有q个询问，每个询问给定两个数l和r，1<=l<=r<=n，求a[l:r]的子序列的最小值之和。例如，给定序列5,2,4,1,3，询问给定的两个数为1和3，那么a[1:3]有6个子序列a[1:1],a[2:2],a[3:3],a[1:2],a[2:3],a[1:3]，这6个子序列的最小值之和为5+2+4+2+2+2=17。

分析

关于ST表的分析

对于静态区间的最值查找，一般都是由ST来实现的，优点有以下三点：

• 代码量少
• 时间复杂度较小，一般的复杂度是\(O(nk)\)的复杂度。
• 空间占有量少，空间复杂度一般是\(O(nk)\)的复杂度。
  但是ST表无法处理待修的问题，也就是动态区间最值问题。但是对于这道题，st表是非常好的选择。

关于莫队的分析

那么在此反观这道题目，我们可以发现一个性质：如果我们当前算出了区间\([l,r]\)的答案，如果要更新到区间\([l,r+1]\)或者是\([l-1,r]\)的话，我们需要查找的答案就是在这个新的加进来的数中。
但是我们原来的答案中的子序列都有增加，简单点来说就是我们有新增的子序列\([l,r+1],[l+1,r+1]..[r+1,r+1]\)，这些区间的最小值的处理是我们需要思考的。
这样的问题我们可以用莫队来解决。

关于前缀和

因为区间最小值，然后扩大了范围，那么我们可以定义数组\(lst\)表示从左边开始第一个比\(a_i\)小的数字，而\(nxt\)表示右边。
这个计算就像用单调栈维护的最长上升子序列的思路一样，用单调栈计算出这个值，复杂度是\(O(n)\)。
那么对于这个值，那么我们就可以结局最小值的问题，但是题目中给出的是贡献的计算，那么我们就用前缀和计算出\([1,l]\)和\([r,n]\)对于答案的贡献，还是需要正的做一遍，倒着做一遍。

ac代码

#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define LL long long
#define N 1000005
using namespace std;
inline char gc() {
    static char buf[1 << 16], *S, *T;
    if (S == T) {
        T = (S = buf) + fread(buf, 1, 1 << 16, stdin);
        if (T == S) return EOF;
    }
    return *S ++;
}
template <typename T>
inline void read(T &x) {
    T w = 1;
    x = 0;
    char ch = gc();
    while (ch < '0' || ch > '9') {
        if (ch == '-') w = -1;
        ch = gc();
    }
    while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc();
    x = x * w;
}
template <typename T>
void write(T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) write(x / 10);
    putchar(x % 10 + 48);
}
struct Stack {
    int s[N], top;
    Stack() {
        memset(s, 0, sizeof(s));
        top = 0;
    }
    void push(int x) {
        s[++ top] = x;
    }
    void pop() {
        --top;
    }
    int get_top() {
        return s[top];
    }
}s;
struct rec_que {
    int l, r, pos, id;
    bool operator <(const rec_que &rhs) const {
        return pos == rhs.pos? r < rhs.r: pos < rhs.pos;
    }
}q[N];
int Log[N], a[N], f[N][22], lst[N], nxt[N], po[N];
LL res, ans[N], suml[N], sumr[N];
int l, r, n, m, block;
void update(int &x, int y, int z) {
    a[y] < a[z] ? x = y : x = z;
}
int query(int l, int r) {
    if (l > r) swap(l, r);
    int k = Log[r - l + 1];
    return a[f[l][k]] < a[f[r - po[k] + 1][k]]? f[l][k]: f[r - po[k] + 1][k];
}
void update1(int l, int r, int fg) {
    int k = query(l, r);
    res += fg *(1ll* a[k] * (r - k + 1) + sumr[l] - sumr[k]);
}
void update2(int l, int r, int fg) {
    int k = query(l, r);
    res += fg *(1ll *a[k] * (k - l + 1) + suml[r] - suml[k]);
}
int main() {
//  freopen("line.in","r",stdin);
//  freopen("line.out","w",stdout);
    read(n); read(m);
    block = sqrt(n);
    Log[0] = -1;
    for (int i = 1; i <= n; i ++) {
        read(a[i]);
        f[i][0] = i;
        Log[i] = Log[i / 2] + 1;
    }
    for (int i = 1; i <= m; i ++) {
        read(q[i].l); read(q[i].r);
        q[i].pos = (q[i].l - 1) / block + 1;
        q[i].id = i;
    }
    po[0] = 1;
    for (int i = 1; i <= 16; i ++) po[i] = po[i - 1]<< 1;
    for (int j = 1; j <= 16; j ++)
        for (int i = 1; i <= n; i ++) {
            f[i][j] = f[i][j - 1];
            if (i + po[j - 1] <= n) update(f[i][j], f[i][j - 1], f[i + po[j - 1]][j - 1]);
        }
    for (int i = 1; i <= n; i ++) {
        while (s.top&& a[s.get_top()] >= a[i]) {
            nxt[s.get_top()] = i;
            s.pop();
        }
        s.push(i);
    }
    while (s.top) {
        nxt[s.get_top()] = n + 1;
        s.pop();
    }
    for (int i = n; i >= 1; i --) {
        while (s.top&&a[s.get_top()] > a[i]) {
            lst[s.get_top()] = i;
            s.pop();
        }
        s.push(i);
    }
    while (s.top) {
        lst[s.get_top()] = 0;
        s.pop();
    }
    for (int i = 1; i <= n; i ++) suml[i] = suml[lst[i]] + (LL)(i - lst[i]) * a[i];
    for (int i = n; i >= 1; i --) sumr[i] = sumr[nxt[i]] + (LL)(nxt[i] - i) * a[i];
    sort(q + 1, q + 1 + m);
    res = a[1];
    l = 1, r = 1;
    for (int i = 1; i <= m; i ++) {
        while (r < q[i].r) r ++, update2(l, r, 1);
        while (l > q[i].l) l --, update1(l, r, 1);
        while (r > q[i].r) update2(l, r, -1), r --;
        while (l < q[i].l) update1(l, r, -1), l ++;
        ans[q[i].id] = res;
    }
    for (int i = 1; i <= m; i ++) {
        write(ans[i]);
        puts("");
    }
    return 0;
}