bzoj 3772

感觉做这种题收获很大。

1、DFS序（广义上）除了用于静态子树操作，也可以用来做点到根的路上某些信息的统计（如点到根的路径上标记了多少个点），如果在加上lca，就可以支持路径的信息查询。

2、树上的可持久化线段树，如果每个节点要维护一个线段树，并且该线段树支持加减操作，那么通过可持久化+lca，搞定一条路径上的线段树的和（当然不仅局限于线段树）。

3、一条树上的路径覆盖另一条路径 <=> 后者的两个端点在前者的路径上。

题解看PoPoQQQ的博客：

http://blog.csdn.net/popoqqq/article/details/43122821

如果不清楚就看看代码。

 /**************************************************************
     Problem: 3772
     User: idy002
     Language: C++
     Result: Accepted
     Time:5824 ms
     Memory:65180 kb
 ****************************************************************/

 #include <cstdio>
 #include <vector>
 #define N 100010
 #define S 4000000
 #define P 16
 using namespace std;

 typedef long long dnt;

 struct Node {
     int s;
     Node *ls, *rs;
 }pool[S], *tail=pool, *root[N], *null=pool;
 struct Qry {
     int u, v;
     Qry(){}
     Qry( int u, int v ):u(u),v(v){}
 };

 int n, m;
 int head[N], dest[N+N], next[N+N], ntot;
 int in[N], out[N], idc;
 int anc[N][P+], dep[N];
 vector<int> vc[N];
 Qry qry[N];

 void insert( int u, int v ) {
     ntot++;
     next[ntot] = head[u];
     dest[ntot] = v;
     head[u] = ntot;
 }
 Node *modify( Node *nd, int lf, int rg, int pos, int delta ) {
     Node *rt = ++tail;
     if( lf==rg ) {
         rt->s = nd->s + delta;
         return rt;
     }
     int mid=(lf+rg)>>;
     if( pos<=mid ) {
         rt->ls = modify( nd->ls, lf, mid, pos, delta );
         rt->rs = nd->rs;
     } else {
         rt->ls = nd->ls;
         rt->rs = modify( nd->rs, mid+, rg, pos, delta );
     }
     rt->s = rt->ls->s + rt->rs->s;
     return rt;
 }
 int query( Node *nd, int lf, int rg, int L, int R ) {
     if( L<=lf && rg<=R ) return nd->s;
     int mid=(lf+rg)>>;
     int rt = ;
     if( L<=mid ) rt += query( nd->ls, lf, mid, L, R );
     if( R>mid ) rt += query( nd->rs, mid+, rg, L, R );
     return rt;
 }
 int query( Node *p1, Node *p2, Node *p3, Node *p4, int L, int R ) {
     /*  (p1+p2-p3-p4) as one tree  */
     int s1, s2, s3, s4;
     s1 = query(p1,,idc,L,R);
     s2 = query(p2,,idc,L,R);
     s3 = query(p3,,idc,L,R);
     s4 = query(p4,,idc,L,R);
     return s1+s2-s3-s4;
 }
 void dfs1( int u ) {
     in[u] = ++idc;
     for( int p=; p<=P; p++ )
         anc[u][p] = anc[anc[u][p-]][p-];
     for( int t=head[u]; t; t=next[t] ) {
         int v=dest[t];
         if( v==anc[u][] ) continue;
         anc[v][] = u;
         dep[v] = dep[u]+;
         dfs1(v);
     }
     out[u] = ++idc;
 }
 void dfs2( int u ) {
     root[u] = root[anc[u][]];
     for( int t=; t<vc[u].size(); t++ ) {
         int v=vc[u][t];
         root[u] = modify( root[u], , idc, in[v], + );
         root[u] = modify( root[u], , idc, out[v], - );
     }
     for( int t=head[u]; t; t=next[t] ) {
         int v=dest[t];
         if( v==anc[u][] ) continue;
         dfs2(v);
     }
 }
 int lca( int u, int v ) {
     if( dep[u]<dep[v] ) swap(u,v);
     int t=dep[u]-dep[v];
     for( int p=; t; t>>=,p++ )
         if( t& ) u=anc[u][p];
     if( u==v ) return u;
     for( int p=P; p>= && anc[u][]!=anc[v][]; p-- )
         if( anc[u][p]!=anc[v][p] )
             u=anc[u][p], v=anc[v][p];
     return anc[u][];
 }
 dnt gcd( dnt a, dnt b ) {
     return b ? gcd(b,a%b) : a;
 }
 int main() {
     scanf( "%d%d", &n, &m );
     for( int i=,u,v; i<n; i++ ) {
         scanf( "%d%d", &u, &v );
         insert( u, v );
         insert( v, u );
     }
     for( int i=,u,v; i<=m; i++ ) {
         scanf( "%d%d", &u, &v );
         vc[u].push_back(v);
         qry[i] = Qry(u,v);
     }

     anc[][] = ;
     dep[] = ;
     dfs1();

     null->ls = null->rs = null;
     root[] = null;
     dfs2();

     dnt cnt = , tot = , cd = ;
     for( int i=; i<=m; i++ ) {
         int u=qry[i].u, v=qry[i].v, ca=lca(u,v);
         cnt += query( root[u], root[v], root[ca], root[anc[ca][]], in[ca], in[u] );
         cnt += query( root[u], root[v], root[ca], root[anc[ca][]], in[ca], in[v] );
         cnt -= query( root[u], root[v], root[ca], root[anc[ca][]], in[ca], in[ca] );
         cnt --;
     }
     tot = (dnt)m*(m-)/;
     cd = gcd(tot,cnt);
     printf( "%lld/%lld\n", cnt/cd, tot/cd );
 }