BZOJ3533:[SDOI2014]向量集(线段树,三分,凸包)

Description

维护一个向量集合，在线支持以下操作：
"A x y (|x|，|y| < =10^8)"：加入向量(x，y);
" Q x y l r (|x|，|y| < =10^8，1 < =L < =R < =T，其中T为已经加入的向量个数)询问第L个到第R个加入的向量与向量(x，y)的点积的最大值。
集合初始时为空。

Input

输入的第一行包含整数N和字符s，分别表示操作数和数据类别；
接下来N行，每行一个操作，格式如上所述。
请注意s≠'E'时，输入中的所有整数都经过了加密。你可以使用以下程序
得到原始输入：
inline int decode (int x long long lastans) {
     return x ^ (lastans & Ox7fffffff);
}
其中x为程序读入的数，lastans为之前最后一次询问的答案。在第一次询问之前，lastans=0。

注：向量(x，y)和(z，W)的点积定义为xz+yw。

Output

对每个Q操作，输出一个整数表示答案。

Sample Input

6 A
A 3 2
Q 1 5 1 1
A 15 14
A 12 9
Q 12 8 12 15
Q 21 18 19 18

Sample Output

13
17
17

解释：解密之后的输入为
6 E
A 3 2
Q 1 5 1 1
A 2 3
A 1 4
Q 1 5 1 2
Q 4 3 2 3

HINT

1 < =N < =4×10^5

Solution

设查询的点为$(a,b)$，那么我们需要在当前平面上找一个点$(x,y)$，使得$ax+by=c$的$c$最大化。

把式子化一下为$y=-\frac{a}{b}x+\frac{c}{b}$。

也就是斜率固定，我们要最大化$c$。比较显然的是这条直线肯定是在凸包上取到答案，现在的问题是怎么维护这个凸包。

可以发现因为我们只需要点积的最大值，并不需要凸包的具体形态，所以我们可以开一颗线段树，每个节点维护对应区间的凸包，查询时把区间对应到线段树上的$log$个区间然后取$max$就好了。

现在的问题是怎么修改。如果每次修改都重构线段树节点上的凸包的话，一次修改是$nlogn$的。

不过我们发现可以不用一次修改所有的节点，线段树上的一个区间，会被用到当且仅当这个区间内的点已经全被插入了。这样一次修改的复杂度就是均摊$logn$的了，复杂度证明还是比较显然的……

当$b>0$时，截距越大，$c$越大，我们在上凸壳上三分。

当$b<0$时，截距越小，$c$越大，我们在下凸壳上三分。

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<vector>
 #include<cmath>
 #include<algorithm>
 #define N (400009)
 #define LL long long
 using namespace std;

 struct Vector
 {
     LL x,y;
     Vector(double xx=,double yy=)
     {
         x=xx; y=yy;
     }
     bool operator < (const Vector &a) const
     {
         return x==a.x?y<a.y:x<a.x;
     }
 }a[N],P[N];
 typedef Vector Point;

 int n,x,y,l,r,cnt;
 LL ans;
 char s[],opt[];
 vector<Point>U[N<<],D[N<<];

 Vector operator - (Vector a,Vector b) {return Vector(a.x-b.x,a.y-b.y);}
 LL Cross(Vector a,Vector b) {return a.x*b.y-a.y*b.x;}
 LL Dot(Vector a,Vector b) {return a.x*b.x+a.y*b.y;}

 void decode(int &x)
 {
     x=x^(ans&0x7fffffff);
 }

 void ConvexHull(int now,int l,int r)
 {
     for (int i=l; i<=r; ++i) a[i]=P[i];
     sort(a+l,a+r+);
     int h=;
     for (int i=l; i<=r; ++i)
     {
         while (h> && Cross(a[i]-U[now][h-],U[now][h-]-U[now][h-])<=)
             h--, U[now].pop_back();
         h++; U[now].push_back(a[i]);
     }
     h=;
     for (int i=l; i<=r; ++i)
     {
         while (h> && Cross(a[i]-D[now][h-],D[now][h-]-D[now][h-])>=)
             h--, D[now].pop_back();
         h++; D[now].push_back(a[i]);
     }
 }

 void Update(int now,int l,int r,int x)
 {
     if (l==r)
     {
         U[now].push_back(P[x]);
         D[now].push_back(P[x]);
         return;
     }
     int mid=(l+r)>>;
     if (x<=mid) Update(now<<,l,mid,x);
     else Update(now<<|,mid+,r,x);
     if (x==r) ConvexHull(now,l,r);
 }

 LL Query(int now,int l,int r,int l1,int r1)
 {
     if (l>r1 || r<l1) return -1e18;
     if (l1<=l && r<=r1)
     {
         if (y>)
         {
             int L=,R=U[now].size()-;
             Point p=Point(x,y);
             if (L==R) return Dot(p,U[now][L]);
             else if (L+==R) return max(Dot(p,U[now][L]),Dot(p,U[now][R]));
             while (R-L>=)
             {
                 int lmid=L+(R-L+)/,rmid=L+(R-L+)/*;
                 LL ans1=Dot(p,U[now][lmid]);
                 LL ans2=Dot(p,U[now][rmid]);
                 if (ans1>ans2) R=rmid;
                 else L=lmid;
             }
             return max(Dot(p,U[now][L]),max(Dot(p,U[now][R]),Dot(p,U[now][R-])));
         }
         else
         {
             int L=,R=D[now].size()-;
             Point p=Point(x,y);
             while (R-L>=)
             {
                 int lmid=L+(R-L+)/,rmid=L+(R-L+)/*;
                 LL ans1=Dot(p,D[now][lmid]);
                 LL ans2=Dot(p,D[now][rmid]);
                 if (ans1>ans2) R=rmid;
                 else L=lmid;
             }
             return max(Dot(p,D[now][L]),max(Dot(p,D[now][R]),Dot(p,D[now][R-])));
         }
     }
     int mid=(l+r)>>;
     return max(Query(now<<,l,mid,l1,r1),Query(now<<|,mid+,r,l1,r1));
 }

 int main()
 {
     scanf("%d%s",&n,s);
     for (int i=; i<=n; ++i)
     {
         scanf("%s",opt);
         if (opt[]=='A')
         {
             scanf("%d%d",&x,&y);
             if (s[]!='E') decode(x), decode(y);
             P[++cnt]=Point(x,y);
             Update(,,n,cnt);
         }
         else
         {
             scanf("%d%d%d%d",&x,&y,&l,&r);
             if (s[]!='E') decode(x), decode(y), decode(l), decode(r);
             ans=Query(,,n,l,r);
             printf("%lld\n",ans);
         }
     }
 }