激！QTREE系列

我现在才开始刷 QTREE 是不是太弱了？算了不管他……

QTREE: 树链剖分裸题（据说 lct 会超时……该说是真不愧有 spoj 的气息吗？）

#include <cstdio>
#include <cstring>
const int sizeOfPoint=10001;
const int sizeOfEdge=20002;
const int sizeOfNode=40004;

inline void swap(int & , int & );
inline int max(int, int);
inline char getch();
inline int getint();
inline void putint(int);

struct edge {int index, point, dist; edge * next;};
edge memory_edge[sizeOfEdge], * port_edge=memory_edge;
inline edge * newedge(int, int, int, edge * );
inline void link(int, int, int, int);

struct node {int c; node * l, * r;};
node memory_node[sizeOfNode], * port_node=memory_node;
inline node * newnode();
node * build(int, int);
void update(node * , int, int, int, int);
int query(node * , int, int, int, int);

edge * e[sizeOfPoint];
int d[sizeOfPoint], f[sizeOfPoint], s[sizeOfPoint];
int num, idx[sizeOfPoint], son[sizeOfPoint], top[sizeOfPoint];
void dfs(int);
void divide(int, int);
inline int query(int, int);

int c, n;
int a[sizeOfPoint], k[sizeOfPoint];
node * t;
inline void clear();

int main()
{
    for (c=getint();c;c--)
    {
        clear();

        n=getint();
        for (int i=1;i<n;i++)
        {
            int u=getint(), v=getint(), d=getint();
            link(i, u, v, d);
        }
        dfs(1);
        divide(1, 1);

        t=build(1, n);
        for (int i=1;i<=n;i++)
            update(t, 1, n, idx[i], a[i]);

        while (true)
        {
            char ch=getch();
            if (ch=='D') break;
            else if (ch=='Q')
            {
                int u=getint(), v=getint();
                putint(query(u, v));
            }
            else if (ch=='C')
            {
                int u=getint(), v=getint();
                a[k[u]]=v;
                update(t, 1, n, idx[k[u]], v);
            }
        }
    }

    return 0;
}

inline void swap(int & x, int & y)
{
    int t=x; x=y; y=t;
}
inline int max(int x, int y)
{
    return x>y?x:y;
}
inline char getch()
{
    register char ch;
    do ch=getchar(); while (ch!='Q' && ch!='C' && ch!='D');
    return ch;
}
inline int getint()
{
    register int num=0;
    register char ch=0, last;
    do last=ch, ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    if (last=='-') num=-num;
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num<0) putchar('-'), num=-num;
    if (num==0) stack[top=1]='0';
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}

inline edge * newedge(int index, int point, int dist, edge * next)
{
    edge * ret=port_edge++;
    ret->index=index; ret->point=point; ret->dist=dist; ret->next=next;
    return ret;
}
inline void link(int i, int u, int v, int d)
{
    e[u]=newedge(i, v, d, e[u]);
    e[v]=newedge(i, u, d, e[v]);
}

inline node * newnode()
{
    node * ret=port_node++;
    ret->c=0; ret->l=NULL; ret->r=NULL;
    return ret;
}
node * build(int l, int r)
{
    node * t=newnode();

    if (l==r)
        return t;

    int m=(l+r)>>1;
    t->l=build(l, m);
    t->r=build(m+1, r);
    t->c=max(t->l->c, t->r->c);

    return t;
}
void update(node * t, int l, int r, int k, int v)
{
    if (l==r)
    {
        t->c=v;
        return ;
    }

    int m=(l+r)>>1;
    if (k<=m) update(t->l, l, m, k, v);
    else update(t->r, m+1, r, k, v);
    t->c=max(t->l->c, t->r->c);
}
int query(node * t, int l, int r, int ql, int qr)
{
    if (l==ql && r==qr)
        return t->c;

    int m=(l+r)>>1;
    if (qr<=m) return query(t->l, l, m, ql, qr);
    else if (ql>m) return query(t->r, m+1, r, ql, qr);
    else return max(query(t->l, l, m, ql, m), query(t->r, m+1, r, m+1, qr));
}

void dfs(int u)
{
    s[u]=1;
    for (edge * i=e[u];i;i=i->next) if (f[i->point]==-1)
    {
        a[i->point]=i->dist; k[i->index]=i->point;
        f[i->point]=u; d[i->point]=d[u]+1;
        dfs(i->point);
        if (s[i->point]>s[son[u]])
            son[u]=i->point;
    }
}
void divide(int u, int top_u)
{
    idx[u]=++num; top[u]=top_u;
    if (son[u]) divide(son[u], top_u);
    for (edge * i=e[u];i;i=i->next) if (!idx[i->point])
        divide(i->point, i->point);
}
inline int query(int u, int v)
{
    int ret=0;

    while (top[u]!=top[v])
    {
        if (d[top[u]]<d[top[v]]) swap(u, v);
        ret=max(ret, query(t, 1, n, idx[top[u]], idx[u]));
        u=f[top[u]];
    }
    if (u==v) return ret;

    if (d[u]>d[v]) swap(u, v);
    ret=max(ret, query(t, 1, n, idx[u]+1, idx[v]));

    return ret;
}

inline void clear()
{
    memset(a, 0, sizeof(a));
    memset(k, 0, sizeof(k));
    port_edge=memory_edge; port_node=memory_node;
    memset(e, 0, sizeof(e));
    memset(s, 0, sizeof(s));
    memset(f, 0xFF, sizeof(f)); f[1]=0;
    memset(d, 0, sizeof(d));
    num=0;
    memset(idx, 0, sizeof(idx));
    memset(son, 0, sizeof(son));
    memset(top, 0, sizeof(top));
}

QTREE2: 因为没有修改操作，机智地用了倍增，在 spoj 上貌似挺快的……

#include <cstdio>
#include <cstring>
const int sizeOfPoint=10001;
const int sizeOfEdge=20002;

inline void swap(int & , int & );
inline int lg(int);
inline int lowbit(int);
inline char getch();
inline int getint();
inline void putint(int);

struct edge {int point, dist; edge * next;};
edge memory[sizeOfEdge], * port=memory;
inline edge * newedge(int, int, edge * );
inline void link(int, int, int);

int c, n;
edge * e[sizeOfPoint];
int a[sizeOfPoint], s[sizeOfPoint];
int f[20][sizeOfPoint], d[sizeOfPoint];
inline void clear();
void dfs(int);
inline int anc(int, int);
inline int lca(int, int);

int main()
{
    for (c=getint();c;c--)
    {
        clear();

        n=getint();
        for (int i=1;i<n;i++)
        {
            int u=getint(), v=getint(), d=getint();
            link(u, v, d);
        }
        dfs(1);

        while (true)
        {
            char ch=getch();
            if (ch=='O') break;
            else if (ch=='I')
            {
                int u=getint(), v=getint(), l=lca(u, v);

                putint(s[u]+s[v]-(s[l]<<1));
            }
            else
            {
                int u=getint(), v=getint(), k=getint(), l=lca(u, v), s=(d[u]-d[l])+(d[v]-d[l])+1;

                if (d[u]-d[l]>=k)
                    putint(anc(u, k-1));
                else
                    putint(anc(v, s-k));
            }
        }
    }

    return 0;
}

inline void swap(int & x, int & y)
{
    int t=x; x=y; y=t;
}
inline int lg(int x)
{
    return x?31-__builtin_clz(x):0;
}
inline int lowbit(int x)
{
    return x & -x;
}
inline char getch()
{
    register char ch;
    do ch=getchar(); while (ch!='D' && ch!='K');
    if (ch=='D') ch=getchar();
    return ch;
}
inline int getint()
{
    register int num=0;
    register char ch=0, last;
    do last=ch, ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    if (last=='-') num=-num;
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num==0) stack[top=1]='0';
    if (num<0) putchar('-'), num=-num;
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}

inline edge * newedge(int point, int dist, edge * next)
{
    edge * ret=port++;
    ret->point=point; ret->dist=dist; ret->next=next;
    return ret;
}
inline void link(int u, int v, int d)
{
    e[u]=newedge(v, d, e[u]);
    e[v]=newedge(u, d, e[v]);
}

inline void clear()
{
    port=memory;
    memset(e, 0, sizeof(e));
    memset(f, 0, sizeof(f));
    memset(d, 0xFF, sizeof(d)); d[1]=0;
    memset(a, 0, sizeof(a));
    memset(s, 0, sizeof(s));
}
void dfs(int u)
{
    if (d[u]>1)
    {
        int _lim=lg(d[u]);
        for (int i=1;i<=_lim;i++)
            f[i][u]=f[i-1][f[i-1][u]];
    }

    for (edge * i=e[u];i;i=i->next) if (d[i->point]==-1)
    {
        f[0][i->point]=u;
        d[i->point]=d[u]+1;
        a[i->point]=i->dist;
        s[i->point]=s[u]+i->dist;
        dfs(i->point);
    }
}
inline int anc(int u, int s)
{
    for ( ;s;s-=lowbit(s))
        u=f[__builtin_ctz(s)][u];
    return u;
}
inline int lca(int u, int v)
{
    if (d[u]<d[v]) swap(u, v);
    u=anc(u, d[u]-d[v]);
    if (u==v) return u;

    for (int i=19;i>=0;i--)
        if (f[i][u]!=f[i][v])
            u=f[i][u],
            v=f[i][v];

    return f[0][u];
}

QTREE4:

#include <cstdio>
#include <cstring>
#include <algorithm>
const int sizeOfPoint=100001;
const int sizeOfEdge=200002;
const int sizeOfSeg=2000002;

inline int lg(int);
inline int rev(int);
inline int getint();
inline void putint(int);

struct edge
{
    int point;
    edge * next;
};
edge memoryOfEdge[sizeOfEdge], * portOfEdge=memoryOfEdge;
inline edge * newedge(int, edge * );
inline void link(int, int);

struct seg
{
    bool b;
    int f;
    seg * l, * r;
    inline seg();
    inline void pushdown();
    inline void maintain();
};
seg * null=new seg();
seg memoryOfSeg[sizeOfSeg], * portOfSeg=memoryOfSeg;
inline void swap(seg *& , seg *& );
seg * newseg(seg * =null);
seg * insert(seg * , int, int);
inline int query(seg * );

int n, m;
bool c[sizeOfPoint];
int f[sizeOfPoint];
int sg[sizeOfPoint], s[sizeOfPoint];
int dp[sizeOfPoint];
int tot, ans[sizeOfPoint];
edge * e[sizeOfPoint];
seg * t[sizeOfPoint];
inline void bfs();

int main()
{
    n=getint(); m=lg(n);
    for (int i=1;i<=n;i++)
        c[i]=getint();
    for (int i=1;i<n;i++)
    {
        int u=getint(), v=getint();
        link(u, v);
    }
    bfs();

    if (!tot) ans[tot++]=-1;
    std::sort(ans, ans+tot);
    for (int i=0;i<tot;i++)
        putint(ans[i]);

    return 0;
}

inline int lg(int x)
{
    return 32-__builtin_clz(x);
}
inline int rev(int x)
{
    int ret=0;
    for (int i=0;i<m;i++)
    {
        ret=(ret<<1)|(x&1);
        x>>=1;
    }
    return ret;
}
inline int getint()
{
    register int num=0;
    register char ch;
    do ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num==0) stack[top=1]='0';
    if (num<0) putchar('-'), num=-num;
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}

inline edge * newedge(int point, edge * next)
{
    edge * ret=portOfEdge++;
    ret->point=point; ret->next=next;
    return ret;
}
inline void link(int u, int v)
{
    e[u]=newedge(v, e[u]);
    e[v]=newedge(u, e[v]);
}

inline seg::seg()
{
    b=false;
    f=0;
    l=r=this;
}
inline void seg::pushdown()
{
    if (f)
    {
        if (f&1)
        {
            swap(l, r);
            l->f^=f>>1, r->f^=f>>1;
        }
        f=0;
    }
}
inline void seg::maintain()
{
    b=l->b&r->b;
}
inline void swap(seg *& a, seg *& b)
{
    seg * t=a; a=b; b=t;
}
inline seg * newseg(seg * t)
{
    seg * newt=portOfSeg++;
    *newt=*t;
    if (t==null) newt->b=false, newt->f=0;
    return newt;
}
seg * insert(seg * t, int k, int d)
{
    t=newseg(t);
    if (d==0) return t->b=true, t;
    t->pushdown();
    if (k&1) t->r=insert(t->r, k>>1, d-1);
    else t->l=insert(t->l, k>>1, d-1);
    t->maintain();
    return t;
}
seg * merge(seg * a, seg * b)
{
    if (a==null || b->b) return b;
    if (b==null || a->b) return a;
    a->pushdown(), b->pushdown();
    seg * t=newseg();
    t->l=merge(a->l, b->l);
    t->r=merge(a->r, b->r);
    t->maintain();
    return t;
}
inline int query(seg * t)
{
    int ret=0;
    for (int i=0;i<m;i++)
    {
        t->pushdown();
        if (t->l->b)
        {
            ret=ret<<1|1;
            t=t->r;
        }
        else
        {
            ret=ret<<1;
            t=t->l;
        }
    }
    return ret;
}

inline void bfs()
{
    static int q[sizeOfPoint];
    int l=0, r=0;
    memset(f, 0xFF, sizeof(f)); f[1]=0;
    for (q[r++]=1;l<r;l++)
    {
        int u=q[l];
        for (edge * i=e[u];i;i=i->next) if (f[i->point]==-1)
        {
            f[i->point]=u;
            q[r++]=i->point;
        }
    }
    for (int h=r-1;h>=0;h--)
    {
        int u=q[h];
        t[u]=newseg();
        for (edge * i=e[u];i;i=i->next) if (f[i->point]==u)
            s[u]^=sg[i->point];
        for (edge * i=e[u];i;i=i->next) if (f[i->point]==u)
        {
            t[i->point]->f^=rev(s[u]^sg[i->point]);
            t[u]=merge(t[u], t[i->point]);
        }
        if (!c[u])
            t[u]=insert(t[u], rev(s[u]), m);
        sg[u]=query(t[u]);
    }
    for (int h=0;h<r;h++)
    {
        int u=q[h];
        if (!c[u] && dp[u]==s[u]) ans[tot++]=u;
        for (edge * i=e[u];i;i=i->next) if (f[i->point]==u)
            dp[i->point]=dp[u]^s[u]^sg[i->point];
    }
}

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
typedef std::priority_queue<struct pair, std::vector<struct pair>, std::greater<struct pair> > heap;
const int sizeOfPoint=100001;
const int sizeOfEdge=200002;
const int sizeOfSeg=400004;

inline int min(int, int);
inline int getint();
inline void putint(int);

struct edge
{
    int point;
    edge * next;
};
edge memoryOfEdge[sizeOfEdge], * portOfEdge=memoryOfEdge;
inline edge * newedge(int, edge * );
inline void link(int, int);

struct pair
{
    int w, u, t;
    inline pair(int, int, int);
};
inline bool operator > (pair, pair);

struct node
{
    int lmin, rmin, sum;
    inline node(int=0, int=0, int=0);
};
inline node merge(node, node);

struct seg
{
    node d;
    seg * l, * r;
    inline void maintain();
};
seg memoryOfSeg[sizeOfSeg], * portOfSeg=memoryOfSeg;
inline seg * newseg();
seg * build(int, int);
void update(seg * , int, int, int);
node query(seg * , int, int, int, int);

int n, m;
int l[sizeOfPoint], r[sizeOfPoint], b[sizeOfPoint];
bool c[sizeOfPoint];
edge * e[sizeOfPoint];
int d[sizeOfPoint], s[sizeOfPoint], f[sizeOfPoint];
int tmp, idx[sizeOfPoint], son[sizeOfPoint], top[sizeOfPoint];
heap h[sizeOfPoint];
int w[sizeOfPoint];
inline void dfs();
inline void getw(int);

int main()
{
    n=getint();
    for (int i=1;i<=n;i++)
    {
        int u=getint(), v=getint();
        link(u, v);
    }
    dfs();

    return 0;
}

inline int min(int x, int y)
{
    return x<y?x:y;
}
inline int getint()
{
    register int num=0;
    register char ch;
    do ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num==0) stack[top=1]='0';
    if (num<0) putchar('-'), num=-num;
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}

inline edge * newedge(int point, edge * next)
{
    edge * ret=portOfEdge++;
    ret->point=point; ret->next=next;
    return ret;
}
inline void link(int u, int v)
{
    e[u]=newedge(v, e[u]);
    e[v]=newedge(u, e[v]);
}

inline pair::pair(int _w, int _u, int _t)
{
    w=_w; u=_u; t=_t;
}
inline bool operator > (pair a, pair b)
{
    return a.w>b.w;
}

inline node::node(int _lmin, int _rmin, int _sum)
{
    lmin=_lmin; rmin=_rmin; sum=_sum;
}
inline node merge(node a, node b)
{
    node c;
    c.lmin=min(a.lmin, a.sum+1+b.lmin);
    c.rmin=min(b.rmin, a.rmin+1+b.sum);
    c.sum=a.sum+1+b.sum;
    return c;
}

inline void seg::maintain()
{
    d=merge(l->d, r->d);
}
inline seg * newseg()
{
    return portOfSeg++;
}
seg * build(int l, int r)
{
    seg * t=newseg();
    int m=(l+r)>>1;

    if (l==r)
    {
        t->d.lmin=t->d.rmin=w[m];
        t->d.sum=0;
    }
    else
    {
        t->l=build(l, m);
        t->r=build(m+1, r);
        t->maintain();
    }

    return t;
}
void update(seg * t, int l, int r, int k)
{
    int m=(l+r)>>1;

    if (l==r)
        t->d.lmin=t->d.rmin=w[m];
    else
    {
        if (k<=m) update(t->l, l, m, k);
        else update(t->r, m+1, r, k);
        t->maintain();
    }
}
node query(seg * t, int l, int r, int ql, int qr)
{
    if (l==ql && r==qr) return t->d;
    int m=(l+r)>>1;
    if (qr<=m) return query(t->l, l, m, ql, qr);
    else if (ql>m) return query(t->r, m+1, r, ql, qr);
    else return merge(query(t->l, l, m, ql, m), query(t->r, m+1, r, m+1, qr));
}

inline void dfs()
{
    static edge * t[sizeOfPoint];
    memmove(t, e, sizeof(e));
}