UOJ 191

有一个初始为空的向量序列，要求你支持3种操作：

1. 在末尾加入一个新向量
2. 删除末尾的向量
3. 询问区间中向量与给定向量的叉积最大值

令$m$为操作数，$n$为插入操作数。

$$mle 5 imes 10^5,n le 3 imes 10^5$$

多组数据（不超过3组），3秒，64M。

先将叉积转成点积。

考虑操作实际上把这个序列变成了一棵树，而询问相当于询问树上的一条没有拐点的链。

一个显然的结论是答案一定在凸壳上，为了处理询问，可以直接链剖，但是空间会被卡。

为了把空间复杂度降到$O(n)$，我们选择点分，在每一个分治出的连通块里，设深度最小的节点为$R$，重心为$G$，我们每次处理$R$到$G$的路径上的点对$R$子树内的询问的贡献。

具体的说，每个询问相当于询问当前路径的一个前缀上的答案，我们发现询问在按极角序排序后，在凸壳上的答案是单调的，可以扫一遍得到贡献。

那么直接CDQ分治就行了。

时间复杂度$O(mlog^2 n)$。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-10, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...
", __FUNCTION__, __LINE__)

const int MAXN = 300000 + 5, MAXM = 500000 + 5, MOD = 998244353;

struct Input {
  char buf[1 << 22], *st, *ed;
  
  Input() {
#ifndef ONLINE_JUDGE
    freopen("unknown.in", "r", stdin);
#endif
  }
  
  char get() {
    if (st == ed) {
      ed = buf + fread(st = buf, 1, 1 << 22, stdin);
    }
    return *st ++;
  }
  
  friend Input &operator>>(Input &io, int &x) {
    x = 0;
    static char ch;
    int f = 1;
    while (!isdigit(ch = io.get())) {
      if (ch == '-') {
        f = -1;
      }
    }
    do {
      x = x * 10 + ch - '0';
    } while (isdigit(ch = io.get()));
    x *= f;
    return io;
  }
} cin;

struct Point {
  int x, y;

  Point() {}
  Point(int _x, int _y) : x(_x), y(_y) {}
};

typedef Point Vector;

IL Vector operator+(const Vector &a, const Vector &b) {
  return Vector(a.x + b.x, a.y + b.y);
}

IL Vector operator-(const Vector &a, const Vector &b) {
  return Vector(a.x - b.x, a.y - b.y);
}

IL bool operator==(const Vector &a, const Vector &b) {
  return a.x == b.x && a.y == b.y;
}

IL bool operator!=(const Vector &a, const Vector &b) {
  return !(a == b);
}

IL bool operator<(const Vector &a, const Vector &b) {
  return a.x == b.x ? a.y < b.y : a.x < b.x;
}

IL bool operator>(const Vector &a, const Vector &b) {
  return a.x == b.x ? a.y > b.y : a.x > b.x; 
}

IL LL dot(const Vector &a, const Vector &b) {
  return (LL)a.x * b.x + (LL)a.y * b.y;
}

IL LL cross(const Vector &a, const Vector &b) {
  return (LL)a.x * b.y - (LL)a.y * b.x;
}

LL answer[MAXM];
int num;

struct Command {
  int opt, l, r, cnt;
  Point pt;
} com[MAXM];

IL bool comp(int a, int b) {
  return cross(com[a].pt, com[b].pt) < 0;
}

struct Tree {
  int hed[MAXN], nxt[MAXN * 2], to[MAXN * 2], fa[MAXN], dep[MAXN], cnt;
  Vector pt[MAXN];
  bool vis[MAXN];
  std::vector<int> queries[MAXN];

  void init() {
    memset(hed, 0, sizeof hed);
    memset(nxt, 0, sizeof nxt);
    memset(to, -1, sizeof to);
    memset(fa, -1, sizeof fa);
    memset(vis, 0, sizeof vis);
    cnt = 0;
  }

  void addEdge(int u, int v) {
    ++ cnt;
    to[cnt] = v;
    nxt[cnt] = hed[u];
    hed[u] = cnt;
  }

  std::vector<Point> solve(int l, int r, std::vector<int> &vp, int ql, int qr, std::vector<int> &vq) {
    if (l + 1 >= r) {
      FOR(i, ql, qr) {
        chkmax(answer[vq[i]], dot(pt[vp[l]], com[vq[i]].pt));
      }
      std::sort(vq.begin() + ql, vq.begin() + qr, comp);
      return std::vector<Point>(1, pt[vp[l]]);
    }
    static int wxh[MAXM];
    int mid = (l + r) >> 1, f = ql, s = qr;
    FOR(i, ql, qr) {
      wxh[com[vq[i]].l > dep[vp[mid]] ? f ++ : -- s] = vq[i];
    }
    std::copy(wxh + ql, wxh + qr, vq.begin() + ql);
    std::vector<Point> conv_l = solve(l, mid, vp, ql, f, vq), conv_r = solve(mid, r, vp, s, qr, vq);
    static Point flx[MAXN];
    std::copy(conv_l.begin(), conv_l.end(), flx + 1);
    int size = conv_l.size();
    LL result = 0;
    for (int i = f, cur = 1; i < qr; ++ i) {
      result = cur > 1 ? dot(flx[cur - 1], com[vq[i]].pt) : -(LL)INF * INF;
      while (cur <= size && chkmax(result, dot(flx[cur], com[vq[i]].pt))) {
        ++ cur;
      }
      chkmax(answer[vq[i]], result);
    }
    std::vector<Point> conv(conv_l.size() + conv_r.size());
    std::merge(conv_l.begin(), conv_l.end(), conv_r.begin(), conv_r.end(), conv.begin());
    static Point stack[MAXN];
    int top = 0;
    for (auto &x : conv) {
      while (top > 1 && cross(x - stack[top - 1], stack[top] - stack[top - 1]) <= 0) {
        -- top;
      }
      stack[++ top] = x;
    }
    std::inplace_merge(vq.begin() + ql, vq.begin() + f, vq.begin() + qr, comp);
    return std::vector<Point>(stack + 1, stack + top + 1);
  }

  void DFS5(int u, int p, int &total) {
    ++ total;
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!vis[v] && v != p) {
        DFS5(v, u, total);
      }
    }
  }

  void DFS4(int u, int root, std::vector<int> &vec, int p) {
    for (auto &x : queries[u]) {
      if (com[x].l <= dep[root]) {
        vec.push_back(x);
      }
    }
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!vis[v] && v != p) {
        DFS4(v, root, vec, u);
      }
    }
  }

  void DFS3(int u, int aim, std::vector<int> &vec, int p) {
    static int stack[MAXN], top;
    stack[++ top] = u;
    if (u == aim) {
      vec = std::vector<int>(stack + 1, stack + top + 1);
    }
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!vis[v] && v != p) {
        DFS3(v, aim, vec, u);
      }
    }
    -- top;
  }

  void DFS2(int u, int &cur, int &d, int total, int p) {
    static int size[MAXN], max[MAXN];
    max[num + 1] = INF;
    size[u] = 1;
    max[u] = 0;
    for (int e = hed[u]; e; e = nxt[e]) {
      int v = to[e];
      if (!vis[v] && v != p) {
        DFS2(v, cur, d, total, u);
        size[u] += size[v];
        chkmax(max[u], size[v]);
      }
    }
    if (~p) {
      chkmax(max[u], total - size[u]);
    }
    if (max[u] < max[cur]) {
      cur = u;
    }
    if (dep[u] < dep[d]) {
      d = u;
    }
  }

  void DFS1(int u, int total) {
    int root = num + 1;
    DFS2(u, root, u, total, -1);
    static std::vector<int> cur;
    cur.clear();
    DFS3(root, u, cur, -1);
    for (auto &x : cur) {
      vis[x] = 1;
    }
    static std::vector<int> qs;
    qs.clear();
    DFS4(root, root, qs, -1);
    for (auto &x : cur) {
      vis[x] = 0;
    }
    vis[root] = 1;
    if (!cur.back()) {
      cur.pop_back();
    }
    std::sort(qs.begin(), qs.end(), [&](int a, int b) {
      return com[a].l > com[b].l;
    });
    solve(0, cur.size(), cur, 0, qs.size(), qs);
    for (int e = hed[root]; e; e = nxt[e]) {
      int v = to[e];
      if (!vis[v]) {
        int size = 0;
        DFS5(v, -1, size);
        DFS1(v, size);
      }
    }
  }
} T;

int main() {
  int _;
  cin >> _;
  while (1) {
    int m;
    cin >> m;
    if (!m) {
      break;
    }
    num = 0;
    For(i, 1, m) {
      answer[i] = -(LL)INF * INF;
    }
    T.init();
    static int stack[MAXN], top;
    top = 0;
    int cur = 0;
    For(i, 1, m) {
      cin >> com[i].opt;
      if (com[i].opt == 1) {
        cin >> com[i].pt.x >> com[i].pt.y;
        T.fa[stack[++ top] = com[i].cnt = ++ num] = cur;
        T.dep[com[i].cnt] = top;
        T.pt[com[i].cnt] = com[i].pt;
        T.addEdge(cur, com[i].cnt);
        T.addEdge(com[i].cnt, cur);
        cur = com[i].cnt;
      } else if (com[i].opt == 2) {
        com[i].cnt = cur = T.fa[cur];
        -- top;
      } else {
        cin >> com[i].l >> com[i].r >> com[i].pt.y >> com[i].pt.x;
        com[i].pt.x = -com[i].pt.x;
        T.queries[stack[com[i].r]].push_back(i); 
      }
    }
    T.DFS1(0, num + 1);
    int result = 0;
    For(i, 1, m) {
      if (com[i].opt == 3) {
        result ^= (answer[i] % MOD + MOD) % MOD;
      }
    }
    For(i, 1, num) {
      T.queries[i].clear();
    }
    printf("%d
", result);
  }
  return 0;
}