ZOJ 2112 Dynamic Rankings

The Company Dynamic Rankings has developed a new kind of computer that is no longer satisfied with the query like to simply find the k-th smallest number of the given N numbers. They have developed a more powerful system such that for N numbers a[1], a[2], ..., a[N], you can ask it like: what is the k-th smallest number of a[i], a[i+1], ..., a[j]? (For some i<=j, 0<k<=j+1-i that you have given to it). More powerful, you can even change the value of some a[i], and continue to query, all the same.

Your task is to write a program for this computer, which

- Reads N numbers from the input (1 <= N <= 50,000)

- Processes M instructions of the input (1 <= M <= 10,000). These instructions include querying the k-th smallest number of a[i], a[i+1], ..., a[j] and change some a[i] to t.

Input

The first line of the input is a single number X (0 < X <= 4), the number of the test cases of the input. Then X blocks each represent a single test case.

The first line of each block contains two integers N and M, representing N numbers and M instruction. It is followed by N lines. The (i+1)-th line represents the number a[i]. Then M lines that is in the following format

Q i j k or
C i t

It represents to query the k-th number of a[i], a[i+1], ..., a[j] and change some a[i] to t, respectively. It is guaranteed that at any time of the operation. Any number a[i] is a non-negative integer that is less than 1,000,000,000.

There're NO breakline between two continuous test cases.

Output

For each querying operation, output one integer to represent the result. (i.e. the k-th smallest number of a[i], a[i+1],..., a[j])

There're NO breakline between two continuous test cases.

Sample Input

2
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6
3

6

用静态主席树存初始的数字，然后用树状数组套线段树存之后的修改操作，可以保证不会超内存了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<set>
using namespace std;
const int maxn = 60505;
const int Maxn = 1000505;
const int low(int x) { return x&-x; }
int T, n, m, a[maxn], b[maxn], c[maxn], tot;
char s[2];

struct question
{
  int f, l, r, k;
}p[maxn];

struct Bit
{
  int n, m, t, tt;
  int L[Maxn], R[Maxn], sum[Maxn], frist[maxn];
  int LL[Maxn], RR[Maxn], Sum[Maxn], Frist[maxn];
  void build(int x, int y)
  {
    tt = t = n = x;   m = y;
    for (int i = 0; i <= n; i++) L[i] = R[i] = sum[i] = 0, frist[i] = i;
    for (int i = 0; i <= n; i++) LL[i] = RR[i] = Sum[i] = 0, Frist[i] = i;
  }
  void Insert(int x, int y, int z)
  {
    int bef = Frist[x - 1], now = Frist[x], l, r, mid;
    Sum[now] = Sum[bef] + z;
    for (l = 1, r = m; l < r;)
    {
      mid = (l + r) >> 1;
      if (y <= mid)
      {
        r = mid;  LL[now] = ++tt;   
        RR[now] = RR[bef];  Sum[tt] = Sum[LL[bef]] + z;
        now = LL[now];  bef = LL[bef];
      }
      else
      {
        l = mid + 1;  LL[now] = LL[bef];  
        RR[now] = ++tt; Sum[tt] = Sum[RR[bef]] + z;
        now = RR[now];  bef = RR[bef];
      }
      LL[tt] = RR[tt] = 0;
    }
  }
  void add(int x, int l, int r, int y, int z)
  {
    sum[x] += z;
    if (l == r) return;
    else
    {
      int mid = (l + r) >> 1;
      if (y <= mid)
      {
        if (!L[x]) { L[x] = ++t; L[t] = R[t] = sum[t] = 0; }
        add(L[x], l, mid, y, z);
      }
      else
      {
        if (!R[x]) { R[x] = ++t; L[t] = R[t] = sum[t] = 0; }
        add(R[x], mid + 1, r, y, z);
      }
    }
  }
  void insert(int x, int y, int z)
  {
    for (int i = x; i <= n; i += low(i)) add(frist[i], 1, m, y, z);
  }
  int query(int x, int y, int k)
  {
    int A, B, a[50], b[50];
    A = B = 0;
    for (int i = x - 1; i; i -= low(i)) a[A++] = frist[i];
    for (int i = y; i; i -= low(i)) b[B++] = frist[i];
    int l, r, result, mid, u = Frist[x - 1], v = Frist[y];
    for (l = 1, r = m; l < r;)
    {
      result = 0;   mid = (l + r) >> 1;
      for (int i = 0; i < B; i++) result += sum[L[b[i]]];
      for (int i = 0; i < A; i++) result -= sum[L[a[i]]];
      result += Sum[LL[v]] - Sum[LL[u]];
      if (k <= result)
      {
        for (int i = 0; i < B; i++) b[i] = L[b[i]];
        for (int i = 0; i < A; i++) a[i] = L[a[i]];
        u = LL[u];  v = LL[v]; r = mid;
      }
      else
      {
        for (int i = 0; i < B; i++) b[i] = R[b[i]];
        for (int i = 0; i < A; i++) a[i] = R[a[i]];
        l = mid + 1;  k -= result;  u = RR[u];  v = RR[v];
      }
    }
    return l;
  }
}bit;

int main()
{
  cin >> T;
  while (T--)
  {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
    tot = n;
    for (int i = 1; i <= m; i++)
    {
      scanf("%s", s);
      if (s[0] == 'Q') p[i].f = 1, scanf("%d%d%d", &p[i].l, &p[i].r, &p[i].k);
      else
      {
        p[i].f = 0;   p[i].k = ++tot;
        scanf("%d%d", &p[i].l, &p[i].r);
        b[tot] = a[tot] = p[i].r;
      }
    }
    sort(a + 1, a + tot + 1);
    int u = unique(a + 1, a + tot + 1) - a - 1;
    bit.build(n, u);
    for (int i = 1; i <= tot; i++) c[i] = lower_bound(a + 1, a + u + 1, b[i]) - a;
    for (int i = 1; i <= n; i++) bit.Insert(i, c[i], 1);
    for (int i = 1; i <= m; i++)
    {
      if (p[i].f) printf("%d\n", a[bit.query(p[i].l, p[i].r, p[i].k)]);
      else if (c[p[i].l] != c[p[i].k])
      {
        bit.insert(p[i].l, c[p[i].l], -1);
        bit.insert(p[i].l, c[p[i].k], 1);
        c[p[i].l] = c[p[i].k];
      }
    }
  }
  return 0;
}

写了个线段树套treap的，结果炸内存了，是指针的问题吗。。。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<functional>
using namespace std;
typedef long long LL;
const int maxn = 5e4 + 10;
const int mod = 1e9 + 7;
int T, n, m, l, r, k, a[maxn];
char ch[5];

struct Node
{
  int v, p, cnt, inc;
  Node *l, *r;
  Node(int v = 0, int p = 0) :v(v), p(p){ l = r = NULL; cnt = inc = 1; }
  void clear(){ if (l) l->clear(); if (r) r->clear(); delete[]this; }
};

struct Treap
{
  #define node Node*
  #define now (*root)
  Node *root;
  void Count(node root)
  {
    root->cnt = root->inc;
    if (root->l) root->cnt += root->l->cnt;
    if (root->r) root->cnt += root->r->cnt;
  }
  void rotate_left(node *root)
  {
    node right = now->r;
    now->r = right->l;
    right->l = now;
    now = right;
    Count(now->l); Count(now);
  }
  void rotate_right(node *root)
  {
    node left = now->l;
    now->l = left->r;
    left->r = now;
    now = left;
    Count(now->r); Count(now); 
  }
  void Insert(node *root, int v, int p)
  {
    if (!now) { now = new Node(v, p); return; }
    if (now->v == v) now->inc++;
    else if (v < now->v)
    {
      Insert(&(now->l), v, p);
      if (now->l->p < now->p) rotate_right(root);
    }
    else
    {
      Insert(&(now->r), v, p);
      if (now->r->p < now->p) rotate_left(root);
    }
    Count(now);
  }
  void add(int x){ Insert(&root, x, rand() % mod); }
  void Delete(node *root, int v)
  {
    if (!now) return;
    if (v < now->v) Delete(&(now->l), v);
    if (v > now->v) Delete(&(now->r), v);
    if (v == now->v)
    {
      if (now->inc > 1) now->inc--;
      else if (!now->l || !now->r)
      {
        node temp = now;
        if (now->l) now = now->l; else now = now->r;
        delete[] temp; return;
      }
      else
      {
        if (now->l->p < now->r->p)
        {
          rotate_right(root);
          Delete(&(now->r), v);
        }
        else
        {
          rotate_left(root);
          Delete(&(now->l), v);
        }
      }
    }
    Count(now);
  }
  void dec(int x){ Delete(&root, x); }
  int find(int x)
  {
    int ans = 0;
    for (node temp = root; temp;)
    {
      int left = temp->l ? temp->l->cnt : 0;
      if (x < temp->v) temp = temp->l;
      else
      {
        if (x == temp->v) return ans + left;
        ans += left + temp->inc;
        temp = temp->r;
      }
    }
    return ans;
  }
  void clear(){ if (root) root->clear(); root=NULL; }
};

struct Tree
{
  Treap f[maxn * 4];
  void insert(int x, int l, int r)
  {
    f[x].clear();
    if (l == r) { scanf("%d", &a[l]); f[x].add(a[l]); return; }
    int mid = l + r >> 1;
    insert(x << 1, l, mid);
    insert(x << 1 | 1, mid + 1, r);
    for (int i = l; i <= r; i++) f[x].add(a[i]);
  }
  int find(int x, int l, int r, int ll, int rr, int v)
  {
    if (ll <= l&&r <= rr) return f[x].find(v);
    int mid = l + r >> 1, ans = 0;
    if (ll <= mid) ans += find(x << 1, l, mid, ll, rr, v);
    if (rr > mid) ans += find(x << 1 | 1, mid + 1, r, ll, rr, v);
    return ans;
  }
  void change(int x, int l, int r, int w, int u, int v)
  {
    f[x].dec(u);  f[x].add(v);
    if (l == r) return;
    int mid = l + r >> 1;
    if (w <= mid) change(x << 1, l, mid, w, u, v);
    else change(x << 1 | 1, mid + 1, r, w, u, v); 
  }
  void revese(int x, int l, int r)
  {
    f[x].clear();
    if (l == r) return;
    int mid = l + r >> 1;
    revese(x << 1, l, mid);
    revese(x << 1 | 1, mid + 1, r);
  }
}st;

int main()
{
  scanf("%d", &T);
  while (T--)
  {
    scanf("%d%d", &n, &m);
    st.insert(1, 1, n);
    while (m--)
    {
      scanf("%s", &ch);
      if (ch[0] == 'Q')
      {
        scanf("%d%d%d", &l, &r, &k);
        int q = 0, h = 1e9;
        while (q < h)
        {
          int mid = q + h >> 1;
          int u = st.find(1, 1, n, l, r, mid);
          if (u > k - 1) h = mid - 1;
          if (u == k - 1) q = mid;
          if (u < k - 1) q = mid + 1;
          if (st.find(1, 1, n, l, r, h) == k - 1) q = h; else h--;
        }
        printf("%d\n", q);
      }
      else
      {
        scanf("%d%d", &l, &r);
        st.change(1, 1, n, l, a[l], r);a[l]=r;
      }
    }
    st.revese(1, 1, n);
  }
  return 0;
}

换了数组来写就好啦，线段树套treap

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;
typedef long long LL;
int T, n, m, l, r, k;
char s[5];

struct Treaps
{
  const static int maxn = 1e6 + 3e5;
  int L[maxn], R[maxn], v[maxn], p[maxn], A[maxn], C[maxn], tot;
  void clear(){ A[0] = L[0] = R[0] = C[0] = 0; tot = 1; }
  int Node(int V, int P){ L[tot] = R[tot] = 0; v[tot] = V; p[tot] = P; A[tot] = C[tot] = 1; return tot++; }
  void Count(int x){ C[x] = A[x] + C[L[x]] + C[R[x]]; }
  void rotate_right(int &x)
  {
    int y = L[x]; L[x] = R[y]; R[y] = x; C[y] = C[x]; Count(x); x = y;
  }
  void rotate_left(int &x)
  {
    int y = R[x]; R[x] = L[y]; L[y] = x; C[y] = C[x]; Count(x); x = y;
  }
  void Insert(int& x, int V, int P)
  {
    if (!x) { x = Node(V, P); return; }
    if (v[x] == V) ++A[x];
    else if (V < v[x])
    {
      Insert(L[x], V, P);
      if (p[x]>p[L[x]]) rotate_right(x);
    }
    else
    {
      Insert(R[x], V, P);
      if (p[x] > p[R[x]]) rotate_left(x);
    }
    Count(x);
  }
  void add(int &x, int V){ Insert(x, V, rand()); }
  void Delete(int &x, int V)
  {
    if (!x) return;
    if (V < v[x]) Delete(L[x], V);
    else if (V > v[x]) Delete(R[x], V);
    else if (A[x] > 1) --A[x];
    else if (!L[x] || !R[x]) x = L[x] + R[x];
    else if (p[L[x]] < p[R[x]]){ rotate_right(x); Delete(R[x], V); }
    else { rotate_left(x); Delete(L[x], V); }
    Count(x);
  }
  void dec(int &x, int V) { Delete(x, V); }
  int find(int x, int V)
  {
    int ans = 0;
    for (int i = x; i; i = V < v[i] ? L[i] : R[i])
    {
      if (v[i] <= V) ans += C[L[i]] + A[i];
    }
    return ans;
  }
};

struct Tree
{
  const static int maxn = 2e5 + 10;
  Treaps t;
  int f[maxn], y[maxn];
  void clear(){ t.clear(); memset(f, 0, sizeof(f)); }
  void insert(int x, int l, int r)
  {
    if (l == r) { scanf("%d", &y[l]); t.add(f[x], y[l]); return; }
    int mid = l + r >> 1;
    insert(x << 1, l, mid);
    insert(x << 1 | 1, mid + 1, r);
    for (int i = l; i <= r; i++) t.add(f[x], y[i]);
  }
  int find(int x, int l, int r, int ll, int rr, int u)
  {
    if (ll <= l&&r <= rr) return t.find(f[x], u);
    int mid = l + r >> 1, ans = 0;
    if (ll <= mid) ans += find(x << 1, l, mid, ll, rr, u);
    if (rr > mid) ans += find(x << 1 | 1, mid + 1, r, ll, rr, u);
    return ans;
  }
  void change(int x, int l, int r, int u, int v)
  {
    t.dec(f[x], y[u]);  t.add(f[x], v);
    if (l == r) return;
    int mid = l + r >> 1;
    if (u <= mid) change(x << 1, l, mid, u, v);
    else change(x << 1 | 1, mid + 1, r, u, v);
  }
}solve;

int main()
{
  scanf("%d", &T);
  while (T--)
  {
    scanf("%d%d", &n, &m);
    solve.clear();
    solve.insert(1, 1, n);
    while (m--)
    {
      scanf("%s", s);
      if (s[0] == 'Q')
      {
        scanf("%d%d%d", &l, &r, &k);
        int q = 0, h = 1e9;
        while (q <= h)
        {
          int mid = q + h >> 1;
          int ans = solve.find(1, 1, n, l, r, mid);
          if (ans >= k) h = mid - 1; else q = mid + 1;
        }
        printf("%d\n", q);
      }
      else
      {
        scanf("%d%d", &l, &r);
        solve.change(1, 1, n, l, r);
        solve.y[l] = r;
      }
    }
  }
  return 0;
}