【BZOJ2850】巧克力王国 [KD-tree]

巧克力王国

Time Limit: 60 Sec  Memory Limit: 512 MB
[Submit][Status][Discuss]

Description

　　巧克力王国里的巧克力都是由牛奶和可可做成的。

　　但是并不是每一块巧克力都受王国人民的欢迎，因为大家都不喜欢过于甜的巧克力。

　　对于每一块巧克力，我们设x和y为其牛奶和可可的含量。

　　由于每个人对于甜的程度都有自己的评判标准，所以每个人都有两个参数a和b，分别为他自己为牛奶和可可定义的权重，因此牛奶和可可含量分别为x和y的巧克力对于他的甜味程度即为ax + by。

　　而每个人又有一个甜味限度c，所有甜味程度大于等于c的巧克力他都无法接受。

　　每块巧克力都有一个美味值h。

　　现在我们想知道对于每个人，他所能接受的巧克力的美味值之和为多少。

Input

　　第一行两个正整数n和m，分别表示巧克力个数和询问个数。接下来n行，每行三个整数x,y,h，含义如题目所示。再

　　接下来m行，每行三个整数a,b,c，含义如题目所示。

Output

　　输出m行，其中第i行表示第i个人所能接受的巧克力的美味值之和。

Sample Input

　　3 3
　　1 2 5
　　3 1 4
　　2 2 1
　　2 1 6
　　1 3 5
　　1 3 7

Sample Output

　　5
　　0
　　4

HINT

　　1 <= n, m <= 50000，1 <= 10^9，-10^9 <= a, b, x, y <= 10^9。

Main idea

　　每个点(x,y)以及价值，对于每个询问给定A,B,C。对于一个点，若A*x+B*y<C则可以获得该点的价值，问每个点可以得到的价值总和。

Solution

　　看到这种在平面上的题，我们显然想到了KD-tree。

　　因为可以离线，所以我们可以直接在建树的时候运用nth_element函数让它平衡。

　　对于每个点记录子树的最大最小的x与y以及总价值，然后KD-tree建树建完之后，查询的时候，如果所有情况都<C，我们就可以直接取走这个子树里面所有的值，如果存在可能的可能性就往下走。

　　PS：nth_element: 将一段序列从中间分开，给定的一个值放在中间(我们取中间的值即可)，剩下两边排放，效率O(n) 。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<map>
 using namespace std;  

 typedef long long s64;

 const int ONE=;
 const int INF=;

 int n,m;
 int x,y,A,B;
 s64 C,h;
 int root;
 s64 Ans;
 int Ran;

 struct power
 {
         int x,y,l,r;
         int maxx,maxy;
         int minx,miny;
         s64 val,sum;
 }a[ONE];

 int get()
 {
         int res=,Q=;char c;
         while( (c=getchar())< || c> )
         if(c=='-')Q=-;
         res=c-;
         while( (c=getchar())>= && c<= )
         res=res*+c-;
         return res*Q;
 }

 namespace KD
 {
         void Update(int i)
         {
             a[i].sum=a[i].val;
             if(a[i].l)
             {
                 a[i].sum+=a[a[i].l].sum;
                 a[i].minx=min(a[i].minx,a[a[i].l].minx);    a[i].miny=min(a[i].miny,a[a[i].l].miny);
                 a[i].maxx=max(a[i].maxx,a[a[i].l].maxx);    a[i].maxy=max(a[i].maxy,a[a[i].l].maxy);
             }
             if(a[i].r)
             {
                 a[i].sum+=a[a[i].r].sum;
                 a[i].minx=min(a[i].minx,a[a[i].r].minx);    a[i].miny=min(a[i].miny,a[a[i].r].miny);
                 a[i].maxx=max(a[i].maxx,a[a[i].r].maxx);    a[i].maxy=max(a[i].maxy,a[a[i].r].maxy);
             }
         }

         int cmp(const power &a,const power &b)
         {
             if(Ran) return a.x<b.x; return a.y<b.y;
         }

         int Build(int l,int r,int T)
         {
             int mid=(l+r)/;
             Ran=T;
             nth_element(a+l,a+mid,a+r+,cmp);
             if(l<mid) a[mid].l = Build(l,mid-,T^);
             if(mid<r) a[mid].r = Build(mid+,r,T^);
             Update(mid);
             return mid;
         }
 }

 int PD(int x,int y)
 {
         return (s64)A*x+(s64)B*y < C ;
 }

 int Check(int i)
 {
         int res=;
         res+= PD(a[i].minx,a[i].miny);
         res+= PD(a[i].minx,a[i].maxy);
         res+= PD(a[i].maxx,a[i].miny);
         res+= PD(a[i].maxx,a[i].maxy);
         return res;
 }

 void Query(int i)
 {
         if(PD(a[i].x,a[i].y)) Ans+=a[i].val;
         if(a[i].l)
         {
             int Record=Check(a[i].l);
             if(Record==) Ans+=a[a[i].l].sum;
             else if(Record) Query(a[i].l);
         }
         if(a[i].r)
         {
             int Record=Check(a[i].r);
             if(Record==) Ans+=a[a[i].r].sum;
             else if(Record) Query(a[i].r);
         }
 }

 int main()
 {
         n=get();    m=get();
         for(int i=;i<=n;i++) a[i].minx=a[i].miny=INF;
         for(int i=;i<=n;i++)
         {
             x=get();    y=get();    scanf("%lld",&h);
             a[i].val=h;
             a[i].x=a[i].minx=a[i].maxx=x;
             a[i].y=a[i].miny=a[i].maxy=y;
         }
         root=KD::Build(,n,);

         while(m--)
         {
             A=get();    B=get();    scanf("%lld",&C);
             Ans=;
             Query(root);
             printf("%lld\n",Ans);
         }

 }