题目描述
给定长度为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;
}