HDU 6649 Data Structure Problem（凸包+平衡树）

首先可以证明，点积最值的点对都是都是在凸包上，套用题解的证明：假设里两个点都不在凸包上, 考虑把一个点换成凸包上的点(不动的那个点), 不管你是要点积最大还是最小, 你都可以把那个不动的点跟原点拉一条直线, 然后把所有的点投影到这条直线上, 要找的无非就是这条直线最前面或者最后面的两个点.这两个点不可能是不在凸包上的点.同理我们可以把另一个点移到凸包上.

由于数据随机生成，那么生成凸包上的点的个数的期望是logn，而且删的点落在凸包上的概率是logn/n，所以只需要对每次删点和加点暴力重构凸包即可。但是删点过程要求剩下的第k个还在的点，那么这就需要用平衡树去维护第k个点的值，直接用stl内部的红黑树。

//        ——By DD_BOND

#include<ext/pb_ds/assoc_container.hpp>
//#include<bits/stdc++.h>
//#include<unordered_map>
//#include<unordered_set>
#include<functional>
#include<algorithm>
#include<iostream>
//#include<ext/rope>
#include<iomanip>
#include<climits>
#include<cstring>
#include<cstdlib>
#include<cstddef>
#include<cstdio>
#include<memory>
#include<vector>
#include<cctype>
#include<string>
#include<cmath>
#include<queue>
#include<deque>
#include<ctime>
#include<stack>
#include<map>
#include<set>

#define fi first
#define se second
#define MP make_pair
#define pb push_back

#pragma GCC optimize(3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

using namespace std;
using namespace __gnu_pbds;
using Tree=tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>;

typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll,ll> Pll;
typedef unsigned long long ull;

const int lim=1e9;
const ll LLMAX=2e18;
const int MAXN=2e5+10;
const double eps=1e-8;
const double pi=acos(-1.0);
const unsigned mul=20190812;
const ll INF=0x3f3f3f3f3f3f3f3f;

inline int dcmp(double x){
    if(fabs(x)<eps)    return 0;
    return (x>0? 1: -1);
}

inline double sqr(double x){ return x*x; }

Tree t;

struct Point{
    ll x,y; int id;
    Point(){ x=0,y=0; }
    Point(ll _x,ll _y):x(_x),y(_y){}
    bool operator ==(const Point &b)const{
        return x==b.x&&y==b.y;
    }
    bool operator <(const Point &b)const{
        return (x-b.x)==0? (y-b.y)<0 : x<b.x;
    }
    Point operator -(const Point &b)const{
        return Point(x-b.x,y-b.y);
    }
};

inline ll cross(Point a,Point b){    //叉积
    return a.x*b.y-a.y*b.x;
}

inline ll dot(Point a,Point b){    //点积
    return a.x*b.x+a.y*b.y;
}

Point tmp[MAXN];
int convex_hull(Point *p,int n,Point *ch){    //求凸包
    int m=0;
    sort(p,p+n);
    for(int i=0;i<n;i++){
        while(m>1&&cross(tmp[m-1]-tmp[m-2],p[i]-tmp[m-1])<=0)    m--;
        tmp[m++]=p[i];
    }
    int k=m;
    for(int i=n-2;i>=0;i--){
        while(m>k&&cross(tmp[m-1]-tmp[m-2],p[i]-tmp[m-1])<=0)    m--;
        tmp[m++]=p[i];
    }
    if(n>1)    m--;
    for(int i=0;i<m;i++)    ch[i]=tmp[i];
    return m;
}

class Magic{
public:
    Magic(unsigned state):state(state),ans(0){}
    unsigned long long retrieve(){
        unsigned modulo=0x7fffffff;
        state=((unsigned long long)state*mul+ans)%modulo;
        unsigned high=state;
        state=((unsigned long long)state*mul+ans)%modulo;
        return high*modulo+state;
    }
    int retrieve(int a,int b){
        return (int)(retrieve()%(b-a+1))+a;
    }
    void submit(unsigned k){
        ans=ans*mul+k;
    }
    unsigned retrieveAns(){
        return ans;
    }
private:
    unsigned state,ans;
};

class DataStructure{
public:
    int n,m;
    Point point[MAXN],rec[MAXN];
    DataStructure(){ n=m=0; }
    void add(int x,int y){
        t.insert(++m);
        rec[m]=Point(x,y);
        point[n]=Point(x,y);
        point[n++].id=m;
        n=convex_hull(point,n,point);
    }
    void erase(int r){
        r=*t.find_by_order(r-1);
        t.erase(r);
        for(int i=0;i<n;i++)
            if(point[i].id==r){
                n=0;
                for(auto i:t)   point[n]=rec[i],point[n++].id=i;
                n=convex_hull(point,n,point);
                break;
            }
    }
    P query(){
        P ans(0,0); ll len=LLMAX;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++){
                ll dis=dot(point[i],point[j]);
                if(dis<len){
                    len=dis;
                    ans=P(point[i].id,point[j].id);
                }
            }
        if(ans.fi>ans.se)   swap(ans.fi,ans.se);
        return ans;
    }
};

int main(void){
    int q;    cin>>q;
    for(int k=0;k<q;++k){
        t.clear();
        unsigned state; string s;   cin>>state>>s;
        DataStructure ds;   Magic magic(state);
        for(char c:s){
            if(c=='a'){
                int x=magic.retrieve(-lim,lim);
                int y=magic.retrieve(-lim,lim);
                ds.add(x,y);
            }
            else if(c=='e'){
                unsigned pos = magic.retrieve(1,t.size());
                ds.erase(pos);
            }
            else if(c=='q'){
                auto best=ds.query();
                magic.submit(best.first);
                magic.submit(best.second);
            }
        }
        cout<<magic.retrieveAns()<<endl;
    }
}