bzoj2850巧克力王国

巧克力王国

Time Limit: 60 Sec  Memory Limit: 512 MB
Submit: 861  Solved: 325
[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。

 

题解：

　　这是一个二维平面问题，应该想到扫描线或者kdtree，

　　但是发现对于扫描线，无法解决问题，因为限制是ax+by，所以对于每个询问是不一样的。

　　所以是不行的，二kdtree是可以解决的，

　　对于暴力只能够一个一个处理，如何一起处理是解决问题的关键，

　　所以需要kdtree。

　　时间复杂度，对于建树是T(n)=f(n)+aT(n/b)=O(n)+2T(n/2)

　　所以得出复杂度是O(n log n)的

　　然后对于询问是n^(1-1/k)是√n的，所以渐进复杂度是O(n√n)的。

 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<iostream>
 #include<cstdio>

 #define ll long long
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch>''||ch<''){if (ch=='-') f=-;ch=getchar();}
     while(ch<=''&&ch>=''){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return x*f;
 }
 ll A,B,C,ans;
 int F,n,m,rt;
 struct Node
 {
     int d[],mx[],mn[],v,l,r;
     ll sum;
     int& operator[](int x)
     {
         return d[x];
     }
     friend bool operator<(Node x,Node y)
     {
         return x[F]<y[F];
     }
 }p[];
 bool check(int x,int y)
 {
     return A*x+B*y<C;
 }
 int cal(Node x)
 {
     int tmp=;
     tmp+=check(x.mn[],x.mn[]);
     tmp+=check(x.mx[],x.mn[]);
     tmp+=check(x.mn[],x.mx[]);
     tmp+=check(x.mx[],x.mx[]);
     return tmp;
 }
 struct kd
 {
     Node t[];
     void update(int p)
     {
         int l=t[p].l,r=t[p].r;
         for (int i=;i<;i++)
         {
             t[p].mn[i]=t[p].mx[i]=t[p][i];
             if (l) t[p].mn[i]=min(t[p].mn[i],t[l].mn[i]);
             if (r) t[p].mn[i]=min(t[p].mn[i],t[r].mn[i]);
             if (l) t[p].mx[i]=max(t[p].mx[i],t[l].mx[i]);
             if (r) t[p].mx[i]=max(t[p].mx[i],t[r].mx[i]);
         }
         t[p].sum=t[p].v+t[l].sum+t[r].sum;
     }
     int build(int l,int r,int now)
     {
         F=now;
         int mid=(l+r)>>;
         nth_element(p+l,p+mid,p+r+);
         t[mid]=p[mid];
         if (l<mid) t[mid].l=build(l,mid-,now^);
         if (r>mid) t[mid].r=build(mid+,r,now^);
         update(mid);
         return mid;
     }
     void query(int p)
     {
         int l=t[p].l,r=t[p].r;
         if (check(t[p][],t[p][]))ans+=t[p].v;
         int tl=,tr=;
         if (l) tl=cal(t[l]);
         if (r) tr=cal(t[r]);
         if (tl==) ans+=t[l].sum;
         else if (tl) query(l);
         if (tr==) ans+=t[r].sum;
         else if (tr) query(r);
     }
 }kd;
 int main()
 {
     n=read(),m=read();
     for (int i=;i<=n;i++)
         p[i][]=read(),p[i][]=read(),p[i].v=read();
     rt=kd.build(,n,);
     while(m--)
     {
         A=read(),B=read(),C=read();
         ans=;
         kd.query(rt);
         printf("%lld\n",ans);
     }
 }