SPOJ QTREE 系列解题报告

题目一 : SPOJ 375 Query On a Tree

http://www.spoj.com/problems/QTREE/

给一个树，求a,b路径上最大边权，或者修改a,b边权为t。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <algorithm>

using namespace std;
const int maxn = 200000 + 5;

int N,pos=0;
char ss[50];

struct SegmentTree{
    int l,r,flag;
    int maxv,minv;
}Node[maxn * 10];

int e[maxn][4];
int size[maxn],dep[maxn],top[maxn],son[maxn];
int fa[maxn],Segnum[maxn],Treenum[maxn];

int tot = 0;
int first[maxn],next[maxn*2];
int u[maxn*2],v[maxn*2];

void clear();
void change(int&,int&);
void Add(int,int);
void dfs_1(int,int,int);
void dfs_2(int,int);
void build(int,int,int);
void update(int,int,int,int);
int query(int,int,int);
int find_max(int,int);
void rever(int,int,int);
void get_rever(int,int);
void pushdown(int);
void pushup(int);

int main(){
    int tcase;
    scanf("%d",&tcase);
    while(tcase --){
        clear();
        int x,y,z;
        scanf("%d",&N);
        for(int i = 1;i < N;++ i){
            scanf("%d%d%d",&e[i][0],&e[i][1],&e[i][2]);
            Add(e[i][0],e[i][1]);
            Add(e[i][1],e[i][0]);
        }    
        
        dfs_1(1,0,1);
        dfs_2(1,1);
        build(1,1,N);    
        for(int i = 1;i < N;++ i){
            if(dep[e[i][0]] > dep[e[i][1]])
                swap(e[i][0],e[i][1]);
            update(1,Segnum[e[i][1]],Segnum[e[i][1]],e[i][2]);    
        }
        while(1){
            scanf("%s",ss);
            if(ss[0] == 'D')
                break;
            scanf("%d%d",&x,&y);
            if(ss[0] == 'C'){
                update(1,Segnum[e[x][1]],Segnum[e[x][1]],y);
            }
            else if(ss[0] == 'Q'){
                printf("%d\n",find_max(x,y));
            }
            else if(ss[0] == 'N'){
                get_rever(x,y);
            }
        }
    } 
    return 0;
}

void clear(){
    pos = 0;tot = 0;
    memset(son,0,sizeof son);
    memset(first,0,sizeof first);
}
void Add(int s,int t){
    ++ tot;
    u[tot] = s;v[tot] = t;
    next[tot] = first[u[tot]];
    first[u[tot]] = tot;
}
void dfs_1(int now,int f,int depth){
    size[now] = 1;
    fa[now] = f;
    dep[now] = depth;
    
    for(int i = first[now];i;i = next[i]){
        if(v[i] != f){
            dfs_1(v[i],now,depth + 1);
            size[now] += size[v[i]];
            if(!son[now] || size[v[i]] > size[son[now]])
                son[now] = v[i];
        }
    }
    return;
}

void dfs_2(int now,int ances){
    top[now] = ances;
    Segnum[now] = ++ pos;
    Treenum[Segnum[now]] = now;
    
    if(!son[now])return;
    dfs_2(son[now],ances);
    
    for(int i = first[now];i;i = next[i]){
        if(v[i] != son[now] && v[i] != fa[now]){
            dfs_2(v[i],v[i]);
        }
    }
    return;
}

void build(int o,int l,int r){
    Node[o].l = l;
    Node[o].r = r;
    Node[o].minv = Node[o].maxv = 0;
    Node[o].flag = 0;
    if(l == r)
        return;
    int Mid = (l + r) >> 1;
    build(o<<1,l,Mid);
    build(o<<1|1,Mid+1,r);
}

void update(int o,int l,int r,int v){
    if(Node[o].l == l && Node[o].r == r){
        Node[o].minv = Node[o].maxv = v;
        Node[o].flag = 0;
        return;
    }
    int Mid = (Node[o].l + Node[o].r) >> 1;
    pushdown(o);
    if(r <= Mid)
        update(o<<1,l,r,v);
    else if(l > Mid)
        update(o<<1|1,l,r,v);
    pushup(o);
}
void pushdown(int o){
    if(Node[o].l == Node[o].r)
        return;
    int lc = o << 1,rc = o << 1 | 1;
    if(Node[o].flag){
        Node[o].flag = 0;
        Node[lc].flag ^= 1;
        Node[rc].flag ^= 1;
        change(Node[rc].minv,Node[rc].maxv);
        change(Node[lc].maxv,Node[lc].minv);
    }
}
void pushup(int o){
    int lc = o << 1,rc = o << 1 | 1;
    Node[o].maxv = max(Node[lc].maxv,Node[rc].maxv);
    Node[o].minv = min(Node[lc].minv,Node[rc].minv);
}

int query(int o,int l,int r){
    if(Node[o].l == l && Node[o].r == r){
        return Node[o].maxv;
    }
    int Mid = (Node[o].l + Node[o].r) >> 1;
    pushdown(o);
    if(r <= Mid)
        return query(o<<1,l,r);
    else if(l > Mid)
        return query(o<<1|1,l,r);
    else
        return max(query(o<<1,l,Mid),query(o<<1|1,Mid+1,r));
    pushup(o);
}
void rever(int o,int l,int r){
    if(Node[o].l == l && Node[o].r == r){
        change(Node[o].maxv,Node[o].minv);
        Node[o].flag ^= 1;
        return;
    }
    int Mid = (Node[o].l + Node[o].r) >> 1;
    pushdown(o);
    if(r <= Mid)
        rever(o<<1,l,r);
    else if(l > Mid)
        rever(o<<1|1,l,r);
    else{
        rever(o<<1,l,Mid);
        rever(o<<1|1,Mid+1,r);
    }
    pushup(o);
}
int find_max(int x,int y){
    int f1 = top[x],f2 = top[y];
    int ret = -100000;
    
    while(f1 != f2){
        if(dep[f1] < dep[f2]){
            swap(f1,f2);
            swap(x,y);
        }
        ret = max(ret,query(1,Segnum[f1],Segnum[x]));
        x = fa[f1];f1 = top[x];
    }
    
    if(x == y)return ret;
    if(dep[x] < dep[y]){
        ret = max(ret,query(1,Segnum[son[x]],Segnum[y]));
    }
    else{
        ret = max(ret,query(1,Segnum[son[y]],Segnum[x]));
    }
    
    return ret;
}

void get_rever(int x,int y){
    int f1 = top[x],f2 = top[y];
    
    while(f1 != f2){
        if(dep[f1] < dep[f2]){
            swap(f1,f2);
            swap(x,y);
        }
        rever(1,Segnum[f1],Segnum[x]);
        x = fa[f1];f1 = top[x];
    }
    if(x == y)return;//如果是针对边的操作， 这个东西不能少。。 
    if(dep[x] < dep[y]){
        rever(1,Segnum[son[x]],Segnum[y]);//如果是边权，注意这里的写法。要下放。 
    }
    else{
        rever(1,Segnum[son[y]],Segnum[x]);
    }
    return;
}

void change(int &a,int &b){
    int tp1 = a,tp2 = b;
    a = -tp2;b = -tp1;
    return;
}

 TLE的但是保证 不WA的LCT

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <iostream>

using namespace std;
const int N = 20000 + 5;

int n;
int top, st[N << 1];
int fa[N], c[N][2], val[N], mx[N];
bool rev[N];

void pushup(int x) {
  int l = c[x][0], r = c[x][1];
  mx[x] = x;
  if(l && val[mx[l]] > val[mx[x]]) mx[x] = mx[l];
  if(r && val[mx[r]] > val[mx[x]]) mx[x] = mx[r];
}

void pushdown(int x) {
  int l = c[x][0], r = c[x][1];
  if(rev[x]) {
    rev[x] ^= 1; rev[l] ^= 1; rev[r] ^= 1;
    swap(c[x][0], c[x][1]);
  }
}

bool isroot(int x) {
  return c[fa[x]][0] != x && c[fa[x]][1] != x;
}

void rotate(int x) {
  int y = fa[x], z = fa[y], l, r;
  if(c[y][0] == x) l = 0, r = 1;
  else l = 1, r = 0;
  if(!isroot(y)) {
    if(c[z][0] == y) c[z][0] = x;
    else c[z][1] = x;
  }
  fa[x] = z; fa[y] = x; fa[c[x][r]] = y;
  c[y][l] = c[x][r]; c[x][r] = y;
  pushup(y); pushup(x);
}

void splay(int x) {
  top = 0; st[++ top] = x;
  for(int i = x; !isroot(i); i = fa[i])
    st[++ top] = fa[i];
  while(top) pushdown(st[top --]);
  while(!isroot(x)) {
    int y = fa[x], z = fa[y];
    if(!isroot(y)) {
      if((c[z][0] == y) ^ (c[y][0] == x)) rotate(x);
      else rotate(y);
    }
    rotate(x);
  }
  pushup(x);
}

void access(int x) {
  int t = 0;
  while(x) {
    splay(x); c[x][1] = t;
    t = x;
    pushup(x); x = fa[x];
  }
}

void mroot(int x) {
  access(x); splay(x); rev[x] ^= 1;
}

void link(int a, int b) {
  mroot(a); fa[a] = b;
}

void cut(int a, int b) {
  mroot(a); access(b); splay(b);
  c[b][0] = fa[c[b][0]] = 0;
}

int Q(int a, int b) {
  mroot(a); access(b); splay(b);
  return val[mx[b]];
}

void C(int a, int b) {
  access(a + n); splay(a + n);
  val[a + n] = b;
}

int main() {
  char ss[10];
  int a, b, t, cs;
  scanf("%d", &t);
  while(t --) {
    memset(fa, 0, sizeof fa);
    memset(rev, 0, sizeof rev);
    memset(c, 0, sizeof c);
    memset(mx, 0, sizeof mx);
    memset(val, 0, sizeof val);
    scanf("%d", &n);
    for(int i = 1; i < n; ++ i) {
      scanf("%d%d%d", &a, &b, &cs);
      val[i + n] = cs;
      mx[i + n] = i + n;
      link(a, i + n); link(b, i + n);
    }
    while(1) {
      scanf("%s", ss);
      if(ss[0] == 'D') break;
      if(ss[0] == 'C') {
        scanf("%d%d", &a, &b);
        C(a, b);
      }
      else {
        scanf("%d%d", &a, &b);
        printf("%d\n", Q(a, b));
      }
    }
  }
  return 0;
}

 

题目二： SPOJ Query On a Tree II

题目大意：

给一个树，两个操作，求a->b距离，求a->b路径上的第k个点。

算法讨论：

用LCA来维护，第k个点也用Lca来跳就可以啦。

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int N = 20000 + 5;

int n, cnt;
int head[N], fa[N], f[N][16];
int dis[N], depth[N];

struct Edge {
  int from, to, dis, next;
}edges[N << 1];

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

void build(int u, int f) {
  fa[u] = f;
  for(int i = head[u]; i; i = edges[i].next) {
    int v = edges[i].to;
    if(v != f) {
      dis[v] = dis[u] + edges[i].dis;
      depth[v] = depth[u] + 1;
      build(v, 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];
}

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

int Q(int a, int b) {
  return dis[a] + dis[b] - 2 * dis[lca(a, b)];
}

int K(int a, int b, int c) {
  int Lca = lca(a, b), res;
  if(depth[a] - depth[Lca] + 1 >= c) {
    res = splca(a, depth[Lca] + (depth[a] - depth[Lca]) - c + 1);
  }
  else {
    c -= (depth[a] - depth[Lca]);
    res = splca(b, depth[Lca] + c - 1);
  }
  return res;
}

void clear() {
  cnt = 0;
  memset(head, 0, sizeof head);
}

int main() {
  int t, u, v, w, a, b, c;
  char ss[10];
  bool flag = false;
  scanf("%d", &t);
  while(t --) {
    if(flag) puts("");
    flag = true;
    clear();
    scanf("%d", &n);
    for(int i = 1; i < n; ++ i) {
      scanf("%d%d%d", &u, &v, &w);
      insert(u, v, w); insert(v, u, w);
    }
    depth[1] = 1;
    dis[1] = 0;
    build(1, 0);
    prepare();
    while(1) {
      scanf("%s", ss);
      if(ss[0] == 'D') {
        if(ss[1] == 'O') break;
        else {
          scanf("%d%d", &a, &b);
          printf("%d\n", Q(a, b));
        }
      }
      else {
        scanf("%d%d%d", &a, &b, &c);
        printf("%d\n", K(a, b, c));
      }
    }
  }
  return 0;
}

 

题目三 SPOJ Query On a Tree III

题目大意：

给出一棵树，每个点有权值，而且互不相同。求以某个点为根的子树中第k小的权值是哪个点。

算法讨论：

我的第一个做法是可持久化线段树 + 区间第K小值。我们知道一个点的子树在DFS序中一定是连续的，所以我们可以查询这个区间的第K小值。这就是可持久化线段树的应用。注意可持久化线段树是NlogN的空间，我居然忘记了，只开了原来的4倍。。。所以有三个点re了。

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int N = 150000 + 5;

int n, m, cnt, tot, pos;
int fa[N], size[N], num[N], mx[N], w[N];
int root[N], rank[N], son[N], head[N], seg[N];

struct Edge {
  int from, to, next;
}edges[N << 1];

struct SegTree {
  int l, r, size;
}Node[N * 16];//注意可持久化线段树是NlogN的空间

struct data {
  int v, pos, id;
  bool operator < (const data &k) const {
    return v < k.v;
  }
}a[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_1(int x, int f) {
  size[x] = 1;
  fa[x] = f;
  for(int i = head[x]; i; i = edges[i].next) {
    int v = edges[i].to;
    if(v != f) {
      dfs_1(v, x);
      size[x] += size[v];
      if(!son[x] || size[v] > size[son[x]])
        son[x] = v;
    }
  }
}

void dfs_2(int x, int ances) {
  mx[x] = num[x] = ++ pos;
  seg[pos] = x;
  if(!son[x]) return;
  dfs_2(son[x], ances);
  mx[x] = max(mx[x], mx[son[x]]);
  for(int i = head[x]; i; i = edges[i].next) {
    int v = edges[i].to;
    if(v != fa[x] && v != son[x]) {
      dfs_2(v, v);
      mx[x] = max(mx[x], mx[v]);
    }
  }
}

void build(int &o, int l, int r) {
  o = ++ tot;
  Node[o].l = Node[o].r = Node[o].size = 0;
  if(l >= r) return;
  int mid = (l + r) >> 1;
  build(Node[o].l, l, mid);
  build(Node[o].r, mid + 1, r);
}

void update(int pre, int &o, int l, int r, int kth) {
  o = ++ tot;
  Node[o] = Node[pre];
  Node[o].size ++;
  if(l >= r) return;
  int mid = (l + r) >> 1;
  if(kth <= mid)
    update(Node[pre].l, Node[o].l, l, mid, kth);
  else
    update(Node[pre].r, Node[o].r, mid + 1, r, kth);
}

int query(int r1, int r2, int l, int r, int kth) {
  if(l >= r) return l;
  int lc = Node[Node[r2].l].size - Node[Node[r1].l].size;
  int mid = (l + r) >> 1;
  if(lc >= kth) {
    int ans = query(Node[r1].l, Node[r2].l, l, mid, kth);
    return ans;
  }
  else {
    int ans = query(Node[r1].r, Node[r2].r, mid + 1, r, kth - lc);
    return ans;
  }
}

int Q(int x, int k) {
  int l = num[x], r = mx[x];
  return  a[query(root[l - 1], root[r], 1, n, k)].id;
}

int main() {
  int u, v, x, k;
  scanf("%d", &n);
  for(int i = 1; i <= n; ++ i) scanf("%d", &w[i]);
  for(int i = 1; i < n; ++ i) {
    scanf("%d%d", &u, &v);
    insert(u, v); insert(v, u);
  }
  dfs_1(1, 0); dfs_2(1, 1);
  for(int i = 1; i <= n; ++ i) {
    a[i].v = w[seg[i]];
    a[i].pos = i;
    a[i].id = seg[i];
  }
  sort(a + 1, a + n + 1);
  for(int i = 1; i <= n; ++ i) {
    rank[a[i].pos] = i;
  }
  build(root[0], 1, n);
  for(int i = 1; i <= n; ++ i) {
    update(root[i - 1], root[i], 1, n, rank[i]);
  }
  scanf("%d", &m);
  for(int i = 1; i <= m; ++ i) {
    scanf("%d%d", &x, &k);
    printf("%d\n", Q(x, k));
  }
  return 0;
}

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int N = 100000 + 5;

int n, m, cnt, tot, pos;
int fa[N], num[N], mx[N], w[N], st[N << 1];
int root[N], rank[N], head[N], seg[N], fast[N];

struct Edge {
  int from, to, next;
}edges[N << 1];

struct SegTree {
  int l, r, size;
}Node[N * 20];

struct data {
  int v, pos, id;
  bool operator < (const data &k) const {
    return v < k.v;
  }
}a[N];

//seg[i]  the ith pos is seg[i]
//num[i] the i's pos in the segment tree.
void dfs() {
  int top = 0;
  st[++ top] = 1;
  while(top) {
    int now = st[top], f = fast[top];
    top --;
    if(!num[now]) {
      num[now] = ++ pos;
      mx[now] = num[now];
      st[++ top] = now;
      fa[now] = f;
      for(int i = head[now]; i; i = edges[i].next) {
        if(edges[i].to != f) {
          st[++ top] = edges[i].to;
          fast[top] = now;
        }
      }
    }
  }
  for(int i = 1; i <= n; ++ i)
    seg[num[i]] = i;
  for(int i = n; i >= 1; -- i) {
    mx[fa[seg[i]]] = max(mx[seg[i]], mx[fa[seg[i]]]);
  }
}

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

void build(int &o, int l, int r) {
  o = ++ tot;
  Node[o].l = Node[o].r = Node[o].size = 0;
  if(l >= r) return;
  int mid = (l + r) >> 1;
  build(Node[o].l, l, mid);
  build(Node[o].r, mid + 1, r);
}

void update(int pre, int &o, int l, int r, int kth) {
  o = ++ tot;
  Node[o] = Node[pre];
  Node[o].size ++;
  if(l >= r) return;
  int mid = (l + r) >> 1;
  if(kth <= mid)
    update(Node[pre].l, Node[o].l, l, mid, kth);
  else
    update(Node[pre].r, Node[o].r, mid + 1, r, kth);
}

int query(int r1, int r2, int l, int r, int kth) {
  if(l >= r) return l;
  int lc = Node[Node[r2].l].size - Node[Node[r1].l].size;
  int mid = (l + r) >> 1;
  if(lc >= kth) {
    int ans = query(Node[r1].l, Node[r2].l, l, mid, kth);
    return ans;
  }
  else {
    int ans = query(Node[r1].r, Node[r2].r, mid + 1, r, kth - lc);
    return ans;
  }
}

int Q(int x, int k) {
  int l = num[x], r = mx[x];
  return  a[query(root[l - 1], root[r], 1, n, k)].id;
}

int main() {
  int u, v, x, k;
  scanf("%d", &n);
  for(int i = 1; i <= n; ++ i) scanf("%d", &w[i]);
  for(int i = 1; i < n; ++ i) {
    scanf("%d%d", &u, &v);
    insert(u, v); insert(v, u);
  }
  dfs();
  for(int i = 1; i <= n; ++ i) {
    a[i].v = w[seg[i]];
    a[i].pos = i;
    a[i].id = seg[i];
  }
  sort(a + 1, a + n + 1);
  for(int i = 1; i <= n; ++ i) {
    rank[a[i].pos] = i;
  }
  build(root[0], 1, n);
  for(int i = 1; i <= n; ++ i) {
    update(root[i - 1], root[i], 1, n, rank[i]);
  }
  scanf("%d", &m);
  for(int i = 1; i <= m; ++ i) {
    scanf("%d%d", &x, &k);
    printf("%d\n", Q(x, k));
  }
  return 0;
}