luogu U17100 自信

最新推荐文章于 2020-05-20 18:17:09 发布

转载最新推荐文章于 2020-05-20 18:17:09 发布 · 88 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/KingSann/articles/9684817.html

本文介绍了一种解决特定算法问题的策略，通过离线处理和单调栈优化，实现高效查询。具体方法是对区间查询进行排序，使用单调栈维护序列，支持元素添加和后缀查询，最终达到优化算法性能的目的。

套路题……

直接做的话似乎不太可做……但是发现这可以离线……

那么就按照右端点升序排序后，维护一个序列，支持末尾加入一个数，或者询问某个后缀的答案

单调栈维护一下新加入的数能更新多少个后缀的答案就行了……

  1 // luogu-judger-enable-o2
  2 #pragma GCC optimize(2)
  3 #pragma GCC optimize(3)
  4 #pragma GCC optimize("Ofast")
  5 %:pragma GCC optimize("Ofast")
  6 %:pragma GCC optimize("inline")
  7 %:pragma GCC optimize("-fgcse")
  8 %:pragma GCC optimize("-fgcse-lm")
  9 %:pragma GCC optimize("-fipa-sra")
 10 %:pragma GCC optimize("-ftree-pre")
 11 %:pragma GCC optimize("-ftree-vrp")
 12 %:pragma GCC optimize("-fpeephole2")
 13 %:pragma GCC optimize("-ffast-math")
 14 %:pragma GCC optimize("-fsched-spec")
 15 %:pragma GCC optimize("unroll-loops")
 16 %:pragma GCC optimize("-falign-jumps")
 17 %:pragma GCC optimize("-falign-loops")
 18 %:pragma GCC optimize("-falign-labels")
 19 %:pragma GCC optimize("-fdevirtualize")
 20 %:pragma GCC optimize("-fcaller-saves")
 21 %:pragma GCC optimize("-fcrossjumping")
 22 %:pragma GCC optimize("-fthread-jumps")
 23 %:pragma GCC optimize("-funroll-loops")
 24 %:pragma GCC optimize("-fwhole-program")
 25 %:pragma GCC optimize("-freorder-blocks")
 26 %:pragma GCC optimize("-fschedule-insns")
 27 %:pragma GCC optimize("inline-functions")
 28 %:pragma GCC optimize("-ftree-tail-merge")
 29 %:pragma GCC optimize("-fschedule-insns2")
 30 %:pragma GCC optimize("-fstrict-aliasing")
 31 %:pragma GCC optimize("-fstrict-overflow")
 32 %:pragma GCC optimize("-falign-functions")
 33 %:pragma GCC optimize("-fcse-skip-blocks")
 34 %:pragma GCC optimize("-fcse-follow-jumps")
 35 %:pragma GCC optimize("-fsched-interblock")
 36 %:pragma GCC optimize("-fpartial-inlining")
 37 %:pragma GCC optimize("no-stack-protector")
 38 %:pragma GCC optimize("-freorder-functions")
 39 %:pragma GCC optimize("-findirect-inlining")
 40 %:pragma GCC optimize("-fhoist-adjacent-loads")
 41 %:pragma GCC optimize("-frerun-cse-after-loop")
 42 %:pragma GCC optimize("inline-small-functions")
 43 %:pragma GCC optimize("-finline-small-functions")
 44 %:pragma GCC optimize("-ftree-switch-conversion")
 45 %:pragma GCC optimize("-foptimize-sibling-calls")
 46 %:pragma GCC optimize("-fexpensive-optimizations")
 47 %:pragma GCC optimize("-funsafe-loop-optimizations")
 48 %:pragma GCC optimize("inline-functions-called-once")
 49 %:pragma GCC optimize("-fdelete-null-pointer-checks")
 50 
 51 #include <bits/stdc++.h>
 52 using namespace std;
 53 typedef long long ll;
 54 const int N = 500000 + 10;
 55 struct FastIO {
 56     static const int S = 1e7;
 57     int wpos;
 58     char wbuf[S];
 59     FastIO() : wpos(0) {}
 60     inline int xchar() {
 61         static char buf[S];
 62         static int len = 0, pos = 0;
 63         if (pos == len)
 64             pos = 0, len = fread(buf, 1, S, stdin);
 65         if (pos == len) exit(0);
 66         return buf[pos++];
 67     }
 68     inline int operator () () {
 69         int c = xchar(), x = 0;
 70         while (c <= 32) c = xchar();
 71         for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
 72         return x;
 73     }
 74     inline ll operator ! () {
 75         int c = xchar(); ll x = 0;
 76         while (c <= 32) c = xchar();
 77         for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
 78         return x;
 79     }
 80     inline void wchar(int x) {
 81         if (wpos == S) fwrite(wbuf, 1, S, stdout), wpos = 0;
 82         wbuf[wpos++] = x;
 83     }
 84     inline void operator () (ll x) {
 85         if (x < 0) wchar('-'), x = -x;
 86         char s[24];
 87         int n = 0;
 88         while (x || !n) s[n++] = '0' + x % 10, x /= 10;
 89         while (n--) wchar(s[n]);
 90         wchar('\n');
 91     }
 92     ~FastIO()
 93     {
 94         if (wpos) fwrite(wbuf, 1, wpos, stdout), wpos = 0;
 95     }
 96 } io;
 97 
 98 int sta[N], top, n, m, ans[N], a[N], bit[N];
 99 inline void add(int x, int y) { for( ; x <= n ; x += x & -x) bit[x] += y; }
100 inline int ask(int x) { int r = 0; for( ; x ; x -= x & -x) r += bit[x]; return r; }
101 
102 struct Q { int l, r, id; } q[N];
103 inline bool operator < (Q a, Q b) { return a.r < b.r; }
104 
105 int main() {
106     n = io(), m = io();
107     for(register int i = 1 ; i <= n ; ++ i)
108         a[i] = io();
109     for(register int i = 1 ; i <= m ; ++ i)
110         q[i] = (Q) { io(), io(), i };
111     sort(q + 1, q + 1 + m);
112     for(register int i = 1, j = 1 ; i <= n ; ++ i) {
113         while(a[sta[top]] >= a[i]) -- top;
114         add(sta[top] + 1, 1), add(i + 1, -1), sta[++ top] = i;
115         while(j <= m && q[j].r == i) ans[q[j].id] = ask(q[j].l), ++ j;
116     }
117     for(register int i = 1 ; i <= m ; ++ i) io(ans[i]);
118 }

luogu U17100 自信

经过各种大力优化后成功302ms滚粗

转载于:https://www.cnblogs.com/KingSann/articles/9684817.html