sdoi2014-向量集-线段树-二分斜率

注意到线段树一个节点只有满了才会被用到，那时再建ConvexHull就行了。。。

#include <bits/stdc++.h>
using namespace std;
namespace my_useful_tools {
#define rep(_i, _k, _j) for(int _i = _k; _i <= _j; ++_i)
#define reu(_i, _k, _j) for(int _i = _k; _i <  _j; ++_i)
#define red(_i, _k, _j) for(int _i = _k; _j <= _i; --_i)
#define foreach(_i, _s) for(typeof(_s.begin()) _i = _s.begin(); _i != _s.end(); ++_i)
#define pb push_back
#define mp make_pair
#define ipir pair<int, int>
#define ivec vector<int>
#define clr(t) memset(t, 0, sizeof t)
#define pse(t, v) memset(t, v, sizeof t)
#define brl puts("")
#define file(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)
#define file_hza freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
#define file_gen(x) freopen(#x".in", "w", stdout);
    const int INF = 0x3f3f3f3f;
    typedef long long LL;
    typedef double DB;
    inline void pc(char c) { putchar(c); }
    template<class T> inline T gcd(T a, T b) { return b ==  ? a : gcd(b, a % b); }
    template<class T> inline void W(T p) { if(p < ) pc('-'), p = -p; if(p /  != ) W(p / ); pc('' + p % ); }
    template<class T> inline void Wn(T p) { W(p), brl; } template<class T> inline void W(T a, T b) { W(a), pc(' '), W(b); }
    template<class T> inline void Wn(T a, T b) { W(a), pc(' '), Wn(b); }
    template<class T> inline void W(T a, T b, T c) { W(a), pc(' '), W(b), pc(' '), W(c); }
    inline char gchar() { char ret = getchar(); for(; ret == '\n' || ret == '\r' || ret == ' '; ret = getchar()); return ret; }
    template<class T> inline void fr(T&ret) { char c = ' '; int flag = ; for(c = getchar(); c != '-' && !('' <= c && c <= ''); c = getchar());
        if(c == '-') flag = -, ret = ; else ret = c - ''; for(c = getchar(); '' <= c && c <= ''; c = getchar()) ret = ret *  + c - '';
        ret = ret * flag;
    }
    inline int fr() { int x; fr(x); return x; }
    template<class T> inline void fr(T&a, T&b) { fr(a), fr(b); } template<class T> inline void fr(T&a, T&b, T&c) { fr(a), fr(b), fr(c); }
    template<class T> inline T fast_pow(T base, T index, T mod = , T ret = ) {
        for(; index; index >>= , base = base * base % mod) if(index & ) ret = ret * base % mod;
        return ret;
    }
};
using namespace my_useful_tools;

const int maxNode = 1e7;
const int maxQueryNode = 4e5 + ;
const int maxSegNode = (maxQueryNode<<);
struct Point {
    int x, y;
    Point() {}
    Point(int x, int y):x(x), y(y) {}
    bool operator < (const Point&rhs) const {
        return x < rhs.x || (x==rhs.x && y < rhs.y);
    }
    Point operator - (const Point&rhs) {
        return Point(x-rhs.x, y-rhs.y);
    }
} pool[maxNode], *loc = pool, P[maxQueryNode];
LL Dot(Point a, Point b) {
    return (LL)a.x*b.x+(LL)a.y*b.y;
}
LL Cross(Point a, Point b) {
    return (LL)a.x*b.y-(LL)a.y*b.x;
}

struct ConvexHull {
    Point *up, *dw;
    int un, dn;
    void buildConvexHull(Point*p, int sz) {
        sort(p, p+sz);
        up = loc;
        int cnt = -;
        reu(i, , sz) {
            while (cnt >  && Cross(p[i]-up[cnt-], up[cnt]-up[cnt-]) <= )
                --cnt;
            ++cnt, up[cnt] = p[i];
        }
        loc += cnt+;
        un = cnt+;
        dw = loc;
        cnt = -;
        reu(i, , sz) {
            while (cnt >  && Cross(p[i]-dw[cnt-], dw[cnt]-dw[cnt-]) >= )
                --cnt;
            ++cnt, dw[cnt] = p[i];
        }
        loc += cnt+;
        dn = cnt+;
    }
    LL qMaxDot(Point p) {
        LL ret = LLONG_MIN;
        int l = , r = un-;
        while (l <= r) {
            if (r - l +  <= ) {
                for (register int i = l; i <= r; ++i) {
                    ret = max(ret, Dot(up[i], p));
                }
                break;
            }
            int mid = (l+r)>>;
            if (Dot(up[mid], p) < Dot(up[mid+], p)) {
                l = mid+;
            } else {
                r = mid;
            }
        }
        l = , r = dn-;
        while (l <= r) {
            if (r - l +  <= ) {
                for (register int i = l; i <= r; ++i) {
                    ret = max(ret, Dot(dw[i], p));
                }
                break;
            }
            int mid = (l+r)>>;
            if (Dot(dw[mid], p) < Dot(dw[mid+], p)) {
                l = mid+;
            } else {
                r = mid;
            }
        }
    //    return ret;
    //    LL tmp = LLONG_MIN;
    //    for (int i = 0; i < un; ++i)
    //        tmp = max(tmp, Dot(up[i], p));
    //    for (int i = 0; i < dn; ++i)
    //        tmp = max(tmp, Dot(dw[i], p));
        return ret;
    }
} ch_pool[maxSegNode], *ch_loc = ch_pool;

struct SegNode {
    SegNode*lc, *rc;
    ConvexHull*ch;
    int l, r, sz;
    SegNode() {
        lc = rc = NULL;
        ch = ch_loc++;
        sz = ;
    }
} sn_pool[maxSegNode], *sn_loc = sn_pool, *root;

void buildSegTree(int l, int r, SegNode*&rt) {
    if (rt == NULL) {
        rt = sn_loc++;
        rt->l = l, rt->r = r;
    }
    if (l == r) return ;
    int mid = (l+r)>>;
    buildSegTree(l, mid, rt->lc), buildSegTree(mid+, r, rt->rc);
}

void addPoint(int pos, SegNode*rt) {
    if (rt->l == rt->r) {
        ++rt->sz;
        if (rt->sz == rt->r-rt->l+)
            rt->ch->buildConvexHull(P+(rt->l), rt->sz);
        return ;
    }
    int mid = (rt->l+rt->r)>>;
    if (pos <= mid) addPoint(pos, rt->lc);
    else addPoint(pos, rt->rc);
    rt->sz = rt->lc->sz+rt->rc->sz;
    if (rt->sz == rt->r-rt->l+)
        rt->ch->buildConvexHull(P+(rt->l), rt->sz);
}

Point qp;
LL Query(int ql, int qr, SegNode*rt) {
    if (ql <= rt->l && rt->r <= qr) {
        return rt->ch->qMaxDot(qp);
    }
    int mid = (rt->l+rt->r)>>;
    LL ret = LLONG_MIN;
    if (ql <= mid) ret = max(ret, Query(ql, qr, rt->lc));
    if (mid < qr) ret = max(ret, Query(ql, qr, rt->rc));
    return ret;
}

int n;
bool e;
LL last_ans = 0LL;

inline int decode(int x) {
    if (e)
        return x ^ (last_ans & 0x7fffffff);
    else return x;
}

void print_tree(SegNode*rt) {
    if (rt == NULL) return ;
    printf("%d %d %d\n", rt->l, rt->r, rt->sz);
    print_tree(rt->lc);
    print_tree(rt->rc);
}

int main() {
    fr(n), e=(gchar()!='E');
    int x, y, ql, qr;
    int cnt = ;
    buildSegTree(, n, root);
    while (n--) {
        if (gchar() == 'A') {
            x = decode(fr()), y = decode(fr());
            P[++cnt] = Point(x, y);
            addPoint(cnt, root);
        } else {
            x = decode(fr()), y = decode(fr());
            ql = decode(fr()), qr = decode(fr());
    //        printf("%d %d %d %d\n", x, y, ql, qr);
            qp = Point(x, y);
            last_ans = Query(ql, qr, root);
            printf("%lld\n", last_ans);
        }
    //    print_tree(root);
    }

    return ;
}