莫队/分块 题目泛做

题目1 BZOJ2453 / 2120

算法讨论：

用pre[i]表示与第i个位置颜色相同的上个位置在哪里，那么对于l...r内，如果一个位置的pre[i] < l，则说明这个颜色是第一次出现。

然后暴力分块。因为修改的次数很少，所以每次修改就重新计算pre[i],对于涉及的块重新构块。然后对于整块的查询，直接在排好序的pre上二分就可以了。

#include <bits/stdc++.h>
 
using namespace std;
 
const int M = 1000000 + 5;
const int N = 10000 + 5;
const int K = 110;
 
inline int read() {
  int x = 0;
  char c = getchar();
 
  while(!isdigit(c)) c = getchar();
  while(isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  return x;
}
 
char ss[5];
int n, m, size, tk;
int ckn[N], b[N], pre[N], last[M], a[N];
int l[K], r[K];
 
void prepare() {
  size = (int) sqrt(n);
  for(int i = 1; i <= n; ++ i) ckn[i] = (i - 1) / size + 1;
  tk = n / size + 1 - (n % size == 0);
  for(int i = 1; i <= tk; ++ i) {
    l[i] = (i - 1) * size + 1;
    r[i] = min(i * size, n);
    for(int j = l[i]; j <= r[i]; ++ j) {
      b[j] = pre[j];
    }
    sort(b + l[i], b + r[i] + 1);
  }
}
 
void reset(int num) {
  for(int i = l[num]; i <= r[num]; ++ i) {
    b[i] = pre[i];
  }
  sort(b + l[num], b + r[num] + 1);
}
 
void update(int x, int v) {
  int tp;
   
  for(int i = 1; i <= n; ++ i) last[a[i]] = 0;
  a[x] = v;
  for(int i = 1; i <= n; ++ i) {
    tp = pre[i];
    pre[i] = last[a[i]];
    if(tp != pre[i]) reset(ckn[i]);
    last[a[i]] = i;
  }
}
 
int bs(int L, int R, int V) {
  int mid, res, Down = L;
 
  if(b[R] < V) return R - L + 1;
  if(b[L] >= V) return 0;
  while(L <= R) {
    mid = L + (R - L) / 2;
    if(b[mid] < V) {
      L = mid + 1;
      res = mid;
    }
    else
      R = mid - 1;
  }
  return res - Down + 1;
}
 
void query(int L, int R) {
  int n1 = ckn[L], n2 = ckn[R];
  int res = 0;
   
  if(n1 == n2) {
    for(int i = L; i <= R; ++ i) {
      if(pre[i] < L) ++ res;
    }
    printf("%d\n", res);
  }
  else {
    for(int i = L; i <= r[n1]; ++ i)
      if(pre[i] < L) ++ res;
    for(int i = l[n2]; i <= R; ++ i)
      if(pre[i] < L) ++ res;
    for(int i = n1 + 1; i < n2; ++ i)
      res += bs(l[i], r[i], L);
    printf("%d\n", res);
  }
}
 
int main() {
  int x, y;
   
  n = read(); m = read();
  for(int i = 1; i <= n; ++ i) a[i] = read();
  for(int i = 1; i <= n; ++ i) {
    pre[i] = last[a[i]];
    last[a[i]] = i;
  }
  prepare();
  for(int i = 1; i <= m; ++ i) {
    scanf("%s", ss);
    x = read(); y = read();
    if(ss[0] == 'Q') {
      query(x, y);
    }
    else {
      update(x, y);
    }
  }
  return 0;
}

 

题目2 BZOJ3052 WC2013 糖果公园

算法讨论：

带修改的树上莫队。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <stack>

using namespace std;

const int N = 100000 + 5;
typedef long long ll;

inline int read() {
  int x = 0;
  char c = getchar();

  while(!isdigit(c)) c = getchar();
  while(isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  return x;
}

int buf[30];

inline void output(ll x) {
  int p = 0;

  buf[0] = 0;
  if(x == 0) p ++;
  else {
    while(x) {
      buf[p ++] = x % 10;
      x /= 10;
    }
  }
  for(int j = p - 1; j >= 0; -- j)
    putchar('0' + buf[j]);
}

ll ans[N], tot = 0;
int n, m, q, size, cnt, tk, tim;
int head[N], fa[N], f[N][18], seq[N], v[N], w[N];
int ckn[N], depth[N], son[N], pre[N], c[N];
bool flag[N]; int vis[N];
stack <int> s;

struct Edge {
  int from, to, next;
}edges[N << 1];
struct Query {
  int x, v, pre;
}C[N];
struct query {
  int id, u, v, t;
  bool operator < (const query &k) const {
    if(ckn[u] == ckn[k.u] && ckn[v] == ckn[k.v]) return t < k.t;
    else if(ckn[u] == ckn[k.u]) return ckn[v] < ckn[k.v];
    else return ckn[u] < ckn[k.u];
  }
}Q[N];

void insert(int from, int to) {
  ++ cnt;
  edges[cnt].from = from; edges[cnt].to = to;
  edges[cnt].next = head[from]; head[from] = cnt;
}

void dfs(int u, int f) {
  fa[u] = f; seq[u] = ++ tim;
  for(int i = head[u]; i; i = edges[i].next) {
    int v = edges[i].to;

    if(v != f) {
      depth[v] = depth[u] + 1;
      dfs(v, u);
      son[u] += son[v];
      if(son[u] >= size) {
        ++ tk;
        son[u] = 0;
        while(!s.empty()) {
          int cur = s.top(); s.pop();
          ckn[cur] = tk;
        }
      }
    }
  }
  s.push(u); son[u] ++;
}

void prepare() {
  memset(f, -1, sizeof f);
  for(int i = 1; i <= n; ++ i) f[i][0] = fa[i];
  for(int j = 1; (1 << j) <= n; ++ j) {
    for(int i = 1; i <= n; ++ i) {
      if(f[i][j - 1] != -1) {
        f[i][j] = f[f[i][j - 1]][j - 1];
      }
    }
  }
}

int lca(int a, int b) {
  int i;

  if(depth[a] < depth[b]) swap(a, b);
  for(i = 0; (1 << i) <= depth[a]; ++ i);
  -- i;
  for(int j = i; j >= 0; -- j) {
    if(depth[a] - depth[b] >= (1 << j))
      a = f[a][j];
  }
  if(a == b) return a;
  for(int j = i; j >= 0; -- j) {
    if(f[a][j] != -1 && f[a][j] != f[b][j]) {
      a = f[a][j];
      b = f[b][j];
    }
  }
  return f[a][0];
}

void rever(int u) {
  if(flag[u]) {
    flag[u] = false;
    tot -= 1LL * w[vis[c[u]]] * v[c[u]];
    vis[c[u]] --;
  }
  else {
    flag[u] = true;
    vis[c[u]] ++;
    tot += 1LL * w[vis[c[u]]] * v[c[u]];
  }
}

void Getpath(int u, int fi) {
  while(u != fi) {
    rever(u);
    u = fa[u];
  }
}

void change(int x, int v) {
  if(flag[x]) {
    rever(x); c[x] = v; rever(x);
  }
  else c[x] = v;
}

void solve(int nl, int nr, int &zl, int &zr, int ts) {
  int Lca;

  Lca = lca(nl, zl);
  Getpath(nl, Lca); Getpath(zl, Lca);
  Lca = lca(nr, zr);
  Getpath(nr, Lca); Getpath(zr, Lca);
  Lca = lca(nl, nr);
  rever(Lca); ans[Q[ts].id] = tot; rever(Lca);
  zl = nl; zr = nr;
}

#define ONLINE_JUDGE

int main() {
  //int __size__ =  64 <<20;  //这里谁<<20位，就是多少M的栈
  //char*__p__ =(char*)malloc(__size__)+ __size__;
  //__asm__("movl %0, %%esp\n"::"r"(__p__));

#ifndef ONLINE_JUDGE
  freopen("park.in", "r", stdin);
  freopen("park.out", "w", stdout);
#endif

  int x, y;

  n = read(); m = read(); q = read();
  for(int i = 1; i <= m; ++ i) v[i] = read();
  for(int i = 1; i <= n; ++ i) w[i] = read();
  for(int i = 1; i < n; ++ i) {
    x = read(); y = read();
    insert(x, y); insert(y, x);
  }
  for(int i = 1; i <= n; ++ i) pre[i] = c[i] = read();
  depth[1] = 1; //size = (int) pow((double) n, (double) 2 / 3);
  size = 1500;
  dfs(1, -1);
  if(!s.empty()) {
    ++ tk;
    while(!s.empty()) {
      int cur = s.top(); s.pop();
      ckn[cur] = tk;
    }
  }
  prepare();

  int type, t1 = 0, t2 = 0;
  
  for(int i = 1; i <= q; ++ i) {
    type = read();
    if(!type) {
      ++ t1;
      C[t1].x = read(); C[t1].v = read(); C[t1].pre = pre[C[t1].x];
      pre[C[t1].x] = C[t1].v;
    }
    else {
      ++ t2;
      Q[t2].u = read(); Q[t2].v = read(); Q[t2].id = t2; Q[t2].t = t1;
      if(seq[Q[t2].u] > seq[Q[t2].v]) swap(Q[t2].u, Q[t2].v);
    }
  }

  int L = 1, R = 1;

  sort(Q + 1, Q + t2 + 1);
  for(int i = 1; i <= Q[1].t; ++ i) {
    change(C[i].x, C[i].v);
  }
  solve(Q[1].u, Q[1].v, L, R, 1);
  for(int i = 2; i <= t2; ++ i) {
    for(int t = Q[i - 1].t + 1; t <= Q[i].t; ++ t)
      change(C[t].x, C[t].v);
    for(int t = Q[i - 1].t; t > Q[i].t; -- t)
      change(C[t].x, C[t].pre);
    solve(Q[i].u, Q[i].v, L, R, i);
  }
  for(int i = 1; i <= t2; ++ i) {
    output(ans[i]);
    puts("");
  }
  
#ifndef ONLINE_JUDGE
  fclose(stdin); fclose(stdout);
#endif
  return 0;
}

 

题目3 NOI2003 文本编辑器

算法讨论：

块状链表。支持插入、删除、找到第x个数的位置等操作。

对于插入操作，

如果要插入的当前块的大小已经满块
那么就新建立一个块，插到原来的两块之间，修改块之间的指针
然后把这个新块之前的块的光标之后的东西复制到新块，然后更新原块的size
然后比较这两个块的大小，把字符插入到较小的那个块中去。

对于删除操作

首先判断当前块的光标之后的元素个数是否比删除的东西多，如果多的话，就直接在块内删除
如果不是，则直接把块改了。

#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
 
using namespace std;
 
const int K = 3000 + 5;
 
char opt[10];
int m;
int cur_mouse, cur_blo, tk, size;
//cur_mouse 记录光标在某个块内的位置
//cur_blo记录当前在某个块 tk是块的总数  size是块的上限大小
struct Node {
  char s[K];
  int sz, pre, next;
}blo[K];
 
void Move() {
  int mouse;
  scanf("%d", &mouse);
  cur_blo = blo[0].next;
  while(mouse > blo[cur_blo].sz) {
    mouse -= blo[cur_blo].sz; cur_blo = blo[cur_blo].next;
  }
  cur_mouse = mouse;
}
 
void Insert() {
  int cmd, imouse = cur_mouse, iblo = cur_blo;
  char c;
  scanf("%d", &cmd);
  c = getchar();
  while(cmd --) {
    while(c < 32 || c > 126) c = getchar();
    if(blo[iblo].sz == size) {
      ++ tk;
      blo[tk].next = blo[iblo].next;
      blo[tk].pre = iblo; blo[tk].sz = size - imouse;
      blo[blo[iblo].next].pre = tk;
      blo[iblo].next = tk;
      for(int i = 1; i <= blo[tk].sz; ++ i)
        blo[tk].s[i] = blo[iblo].s[imouse + i];
      blo[iblo].sz = imouse;
      if(blo[tk].sz < blo[iblo].sz) {
        imouse = 0; iblo = tk;
      }
    }
    blo[iblo].sz ++;
    for(int i = blo[iblo].sz; i > imouse; -- i) {
      blo[iblo].s[i] = blo[iblo].s[i - 1];
    }
    blo[iblo].s[++ imouse] = c;
    c = getchar();
  }
}
 
void Delete() {
  int cmd, imouse = cur_mouse, iblo = cur_blo;
  scanf("%d", &cmd);
  while(cmd) {
    int left = blo[iblo].sz - imouse;
    if(cmd > left) {
      cmd -= left; blo[iblo].sz = imouse;
      iblo = blo[iblo].next;
      imouse = 0;
    }
    else {
      for(int i = imouse + cmd + 1; i <= blo[iblo].sz; ++ i)
        blo[iblo].s[i - cmd] = blo[iblo].s[i];
      blo[iblo].sz -= cmd;
      cmd = 0;
    }
  }
}
 
void Next() {
  if(cur_mouse != blo[cur_blo].sz) cur_mouse ++;
  else {
    cur_blo = blo[cur_blo].next;
    while(blo[cur_blo].sz == 0) {
      blo[blo[cur_blo].pre].next = blo[cur_blo].next;
      blo[blo[cur_blo].next].pre = blo[cur_blo].pre;
      cur_blo = blo[cur_blo].next;
    }
    cur_mouse = 1;
  }
}
 
void Prev() {
  if(cur_mouse) cur_mouse --;
  else {
    cur_blo = blo[cur_blo].pre;
    while(blo[cur_blo].sz == 0) {
      blo[blo[cur_blo].pre].next = blo[cur_blo].next;
      blo[blo[cur_blo].next].pre = blo[cur_blo].pre;
      cur_blo = blo[cur_blo].pre;
    }
    cur_mouse = blo[cur_blo].sz - 1;
  }
}
 
void Get() {
  int cmd, imouse = cur_mouse, iblo = cur_blo;
  scanf("%d", &cmd);
  while(cmd) {
    if(blo[iblo].sz == 0) {
      blo[blo[iblo].next].pre = blo[iblo].pre;
      blo[blo[iblo].pre].next = blo[iblo].next;
      iblo = blo[iblo].next;
    }
    int left = blo[iblo].sz - imouse;
    if(cmd > left) {
      for(int i = imouse + 1; i <= blo[iblo].sz; ++ i)
        putchar(blo[iblo].s[i]);
      cmd -= left;
      imouse = 0;
      iblo = blo[iblo].next;
    }
    else {
      for(int i = imouse + 1; i <= imouse + cmd; ++ i)
        putchar(blo[iblo].s[i]);
      cmd = 0;
    }
  }
  puts("");
}
 
#define ONLINE_JUDGE
 
int main() {
#ifndef ONLINE_JUDGE
  freopen("editor2003.in", "r", stdin);
  freopen("editor2003.out", "w", stdout);
#endif
 
  scanf("%d", &m);
  size = 2000;
  tk = 1; cur_blo = 1;
  blo[0].next = 1;//忘记链表初始化。。额。
  while(m --) {
    scanf("%s", opt);
    if(opt[0] == 'M') Move();
    else if(opt[0] == 'I') Insert();
    else if(opt[0] == 'D') Delete();
    else if(opt[0] == 'G') Get();
    else if(opt[0] == 'P') Prev();
    else if(opt[0] == 'N') Next();
  }
 
#ifndef ONLINE_JUDGE
  fclose(stdin); fclose(stdout);
#endif
 
  return 0;
}