bzoj 4540 [HNOI 2016] 序列 - 莫队算法 - Sparse-Table - 单调栈

题目传送门

　　传送点I

　　传送点II

题目大意

　　给定一个长度为$n$的序列。询问区间$[l, r]$的所有不同的子序列的最小值的和。

　　这里的子序列是连续的。两个子序列不同当且仅当它们的左端点或右端点不同。

　　不会直接上神奇数据结构的做法。

　　考虑莫队。当在一段右边加入一个数后，考虑它产生的贡献。

　　首先找到加入后这一段的最小值，那么左端点在它的左侧的时候这个最小值做出贡献。

　　对于它右边到新加入的数新造成的贡献用同样的方法计算，期望下多带个$log$，然后题目没说数据随机。

　　考虑右边这一部分其实被算重了许多次，因为最小值右边的分段情况比较固定。因为每个"最小值"有一个固定的“恶势力”范围。这个东西可以用前缀和再加上单调栈预处理。

　　求最小的任务就交给st表好了。

Code

 /**
  * bzoj
  * Problem#4540
  * Accepted
  * Time: 10024ms
  * Memory: 34932k
  */
 #include <algorithm>
 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #ifndef WIN32
 #define Auto "%lld"
 #else
 #define Auto "%I64d"
 #endif
 using namespace std;
 typedef bool boolean;

 );
 , bzmax = ;
 #define pii pair<int, int>
 #define fi first
 #define sc second

 typedef class SparseTable {
     public:
         int n;
         int *ar;
         int log2[N];
         pii bz[N][bzmax];

         SparseTable() {    }
         SparseTable(int n, int* ar):n(n) {
             log2[] = ;
             ; i <= n; i++)
                 log2[i] = log2[i >> ] + ;
             ; i < n; i++)
                 bz[i][] = min(pii(ar[i], i), pii(ar[i + ], i + ));
             ; j < bzmax; j++)
                 ; i + ( << j) <= n + ; i++)
                     bz[i][j] = min(bz[i][j - ], bz[i + ( << (j - ))][j - ]);
         }

         int query(int l, int r) {
             if (l == r)    return l;
             int l2 = log2[r - l];
              << l2)][l2]).sc;
         }
 }SparseTable;

 ;
 #define ll long long

 typedef class Query {
     public:
         int l, r, id;
         ll res;

         Query() { }

         boolean operator < (Query b) const {
             if (l / cs != b.l / cs)    return l / cs < b.l / cs;
             return r < b.r;
         }
 }Query;

 int n, m;
 ;
 Query *qs;
 SparseTable st;
 ll *pl, *pr;
 int *ar;
 pii *sta;

 inline void init() {
     scanf("%d%d", &n, &m);
     pl = )];
     pr = )];
     ar = )];
     sta = )];
     qs = )];
     ; i <= n; i++)
         scanf("%d", ar + i);
     st = SparseTable(n, ar);
     ; i <= m; i++)
         scanf("%d%d", &qs[i].l, &qs[i].r), qs[i].id = i;
 }

 inline void prepare() {
     sta[++tp] = pii(, -inf);
     pl[] = , pr[n + ] = ;
     ; i <= n; i++) {
         while (tp && sta[tp].sc >= ar[i])
             tp--;
         pl[i] = pl[sta[tp].fi] + (i - sta[tp].fi) * 1ll * ar[i];
         sta[++tp] = pii(i, ar[i]);
     }

     sta[tp = ] = pii(n + , -inf);
     for (int i = n; i; i--) {
         while (tp && sta[tp].sc >= ar[i])
             tp--;
         pr[i] = pr[sta[tp].fi] + (sta[tp].fi - i) * 1ll * ar[i];
         sta[++tp] = pii(i, ar[i]);
     }
 }

 ll res = ;

 inline void solve() {
     sort(qs + , qs + m + );
     ;
     , p; sid <= n / cs && c <= m; sid++) {
         , mdzzr = ;
         res = ;
         for ( ; c <= m && qs[c].l / cs == sid; c++) {
             while (mdzzr < qs[c].r) {
                 p = st.query(mdzzl, ++mdzzr);
                 res += (p - mdzzl + ) * 1ll * ar[p] + pl[mdzzr] - pl[p];
             }
             while (mdzzl < qs[c].l) {
                 p = st.query(mdzzl, mdzzr);
                 res -= (mdzzr - p + ) * 1ll * ar[p] + pr[mdzzl] - pr[p];
                 mdzzl++;
             }
             while (mdzzl > qs[c].l) {
                 p = st.query(--mdzzl, mdzzr);
                 res += (mdzzr - p + ) * 1ll * ar[p] + pr[mdzzl] - pr[p];
             }
             qs[c].res = res;
         }
     }
     ; i <= m; i++)
         while (qs[i].id != i)
             swap(qs[i], qs[qs[i].id]);
     ; i <= m; i++)
         printf(Auto"\n", qs[i].res);
 }

 int main() {
     init();
     prepare();
     solve();
     ;
 }