codeforces 484E

题意：给定n<=10⁵的数组h,有m<=10⁵的询问，每个询问为l，r，w求[l,r]区间内连续w个的最小高度最大是多少..

思路：首先把h数组从大到小排序，然后用建立一个可持久化的下标线段树，线段树维护区间最长的连续长度为多少。

那么对于每个询问直接二分高度，然后查询这个高度之前的线段树[l,r]区间是否存在至少w个连续的。。

以前总是套主席树模板，这次自己写感觉也还是蛮好写的。。

据说cdq分治也可搞。。应该是整体二分吧。。明天再想想

code：

 /*
  * Author:  Yzcstc
  * Created Time:  2014/11/10 22:17:29
  * File Name: cf276E.cpp
  */
 #include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #include<string>
 #include<map>
 #include<set>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<ctime>
 #define M0(a) memset(a, 0, sizeof(a))
 #define N 101010
 #define M 3100000
 #define x first
 #define y second
 #define ls lson[rt]
 #define rs rson[rt]
 using namespace std;
 typedef pair<int, int> pii;
 struct node{
      int c, lc, rc;
      node(int _c = , int _lc = , int _rc = ):c(_c), lc(_lc), rc(_rc){}
 };
 pair<int, int> p[N];
 int T[N], lc[M], rc[M], c[M], lson[M], rson[M], tot;
 int n, m;

 int build(const int l, const int r){
     int root = tot++;
     c[root] = lc[root] = rc[root] = ;
     if (l < r){
          int mid = (l + r) >> ;
          lson[root] = build(l, mid);
          rson[root] = build(mid+, r);
     }
     return root;
 }

 void push_up(const int& rt, const int& llen, const int &rlen){
      lc[rt] = (c[ls] >= llen) ? llen + lc[rs] : lc[ls];
      rc[rt] = (c[rs] >= rlen) ? rlen + rc[ls] : rc[rs];
      c[rt] = max(c[ls], c[rs]), c[rt] = max(lc[rs] + rc[ls], c[rt]);
 }

 int update(const int rt, const int l, const int r, const int& p){
     int root = tot++;
     if (p <= l && r <= p){
           c[root] = rc[root] = lc[root] = ;
           return root;
     }
     int mid = (l + r) >> ;
     lson[root] = ls, rson[root] = rs;
     if (p <= mid)
           lson[root] = update(ls, l, mid, p);
     else
           rson[root] = update(rs, mid+, r, p);
     push_up(root, mid-l+, r-mid);
     return root;
 }

 node tmp, t;
 void merge(node &a, const node& b,const int& llen,const int& rlen){
      t.c = max(a.c, b.c), t.c = max(t.c, a.rc + b.lc);
      t.lc = (a.lc >= llen) ? a.lc + b.lc : a.lc;
      t.rc = (b.rc >= rlen) ? b.rc + a.rc : b.rc;
      a = t;
 }

 node query(const int& rt,const int& l,const int& r,const int& L,const int& R){
     if (L <= l && r <= R) return node(c[rt], lc[rt], rc[rt]);
     int mid = (l + r) >> ;
     if (R <= mid) return query(ls, l, mid, L, R);
     else if (L > mid) return query(rs, mid + , r, L, R);
     else{
          node res = query(ls, l, mid, L, R);
          tmp = query(rs, mid+, r, L, R);
          merge(res, tmp, mid - max(L, l) + , min(R,r) - mid);
          return res;
     }
 }

 void init(){
      scanf("%d", &n);
      tot = ;
      for (int i = ; i <= n; ++i)
          scanf("%d", &p[i].x), p[i].y = i;
      sort(p + , p +  + n, greater<pii>() );
 }

 void solve(){
      T[] = build(, n);
      for (int i = ; i <= n; ++i)
            T[i] = update(T[i-], , n, p[i].y);
      int q, ll, rr, w, l, r, mid, ans;
      scanf("%d", &q);
      while (q--){
          scanf("%d%d%d", &ll, &rr, &w);
          l = , r = n, ans = ;
          while (l <= r){
                mid = (l + r) >> ;
                if (query(T[mid], , n, ll, rr).c >= w){
                        ans = max(ans, p[mid].x);
                        r = mid - ;
                } else l = mid + ;
          }
          printf("%d\n", ans);
      }

 }

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