HDU5140---Hun Gui Wei Company （主席树）

主席树太强大了，，如果仅仅用来求第k大就太屈才了。。貌似和HDU4605差不多，那个是在图上根据点的顺序建立主席树，这个是根据年龄大小 或者等级高低建立主席树。

题意 大致就是一个二维区间的求和，但是数量级很大，显然不能直接求。

一个想法是可以二维线段树，但是这样显然会MLE。

另外一个还是主席树，以age或者level顺序建立主席树，我是以age建立的。

然后对应的查找就是 查找 tree[LA-1] 、tree[HA]之间的线段树 等级在LL HL之间的salary的和。

题目强制要求在线算，只需要把 k更新后询问的LL HL LA HA 离散化就可以了。

 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 typedef unsigned long long ull;
 typedef long long ll;
 const int inf = 0x3f3f3f3f;
 const double eps = 1e-;
 const int maxn = 1e5+;
 int tot,tree[maxn],c[maxn*],lson[maxn*],rson[maxn*];
 ll sum[maxn*];
 int build (int l, int r)
 {
     int root = tot++;
     c[root] = sum[root] = ;
     if (l != r)
     {
         int mid = (l + r) >> ;
         lson[root] = build(l,mid);
         rson[root] = build(mid+,r);
     }
     return root;
 }
 int MAX;
 int update (int root,int pos,int val,ll sa)
 {
     int newroot = tot++;
     int tmp = newroot;
     int l = , r = MAX;
     c[newroot] = c[root] + val;
     sum[newroot] = sum[root] + sa;
     while (l < r)
     {
         int mid = (l + r) >> ;
         if (pos <= mid)
         {
             r = mid;
             rson[newroot] = rson[root];
             root = lson[root];
             lson[newroot] = tot++;
             newroot = lson[newroot];
         }
         else
         {
             l = mid + ;
             lson[newroot] = lson[root];
             root = rson[root];
             rson[newroot] = tot++;
             newroot = rson[newroot];
         }
         c[newroot] = c[root] + val;
         sum[newroot] = sum[root] + sa;
     }
     return tmp;
 }
 ll query(int root1,int root2,int l,int r,int ua,int ub)
 {
     if (ua > ub)
         return ;
     if (ua <= l && ub >= r)
     {
         return sum[root2] - sum[root1];
     }
     int mid = (l + r) >> ;
     ll t1 = , t2 = ;
     if (ua <= mid)
         t1 = query(lson[root1],lson[root2],l,mid,ua,ub);
     if (ub > mid)
         t2 = query(rson[root1],rson[root2],mid+,r,ua,ub);
     return t1 + t2;
 }
 int lev[maxn],idx1,idx2,age[maxn];

 struct worker
 {
     int s,l,a;
     bool operator < (const worker &rhs)const
     {
         return a < rhs.a;
     }
 } per[maxn];
 int main(void)
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
  #endif
     int n;
     while (~scanf ("%d",&n))
     {
         tot = ;
         memset(sum,,sizeof(sum));
         MAX = n;
         int max_age = ,min_age = inf;
         for (int i = ; i <= n; i++)
         {
             scanf ("%d%d%d",&per[i].s, &per[i].l, &per[i].a);
             age[i-] = per[i].a;
             lev[i-] = per[i].l;
             max_age = max(max_age,age[i-]);
             min_age = min(min_age,age[i-]);
         }
         sort(per+, per++n);
         sort(age, age+n);
         sort(lev, lev+n);
         idx1 = n;
         idx2 = unique(lev,lev+n) - lev;

         tree[] = build(,n);
         for (int i = ; i <= n; i++)
         {
             int tmp = lower_bound(lev,lev+idx2,per[i].l) - lev + ;
             tree[i] = update(tree[i-], tmp, , (ll)per[i].s);
         }
         int Q;
         ll k = ;
         scanf ("%d",&Q);
         for (int i = ; i < Q; i++)
         {
             ll LL,HL,LA,HA;
             scanf ("%I64d%I64d%I64d%I64d",&LL,&HL,&LA,&HA);
             LL += k, HL -= k;
             LA += k, HA -= k;
             if (LL > HL)
                 swap(LL, HL);
             if (LA > HA)
                 swap(LA, HA);
             LA = max(LA, (ll));
             HA = min(HA, (ll));
             int idx_la = lower_bound(age,age+idx1,LA) - age + ;
             int idx_ha = lower_bound(age,age+idx1,HA) - age + ;
             if (age[idx_ha-] == HA)
             {
                 while (age[idx_ha-] == HA && idx_ha <= n)
                     idx_ha ++;
                 idx_ha--;
             }
             else
                 idx_ha--;
             LL = max(LL,(ll));
             HL = min(HL,(ll));
             int i1 = lower_bound(lev,lev+idx2,LL) - lev + ;
             int i2 = lower_bound(lev,lev+idx2,HL) - lev + ;
             if (lev[i2-] > HL)
                 i2--;
             k = query(tree[idx_la-],tree[idx_ha],,MAX,i1,i2);
             printf("%I64d\n",k);
         }
     }
     return ;
 }

 /*
 5
 1 2 2
 2 3 3
 3 4 4
 4 5 6
 6 5 8
 1
 2 3 2 8

 3
 5 6 4
 2 8 6
 4 8 6
 1
 6 8 4 6
 */