bzoj 3757 树上莫队

感谢以下文章作者：

http://blog.csdn.net/kuribohg/article/details/41458639

http://vfleaking.blog.163.com/blog/static/174807634201311011201627/

http://blog.csdn.net/jiangyuze831/article/details/41476865

http://hzwer.com/5259.html

做了树上的莫队，感觉对这个算法的思想理解更深了

先分块，不论怎么分，要求同一块中的节点之间的距离不超过O(n^0.5)

然后将图的DFS序搞出来

然后将询问（u,v)，以u所在的块为第一关键字，以v在dfs序中的位置为第二关键字排序。

然后弄个初始状态，然后就在图上按照询问的顺序“爬”（从(u,v)的状态转移到(u',v')，细节见vfleaking文章）。

至于复杂度，和序列型莫队的分析是一样的，我们的时间开销主要花在“爬”上，我们将爬的开销分成两部分来算：

第一部分：(u,v)中u改变造成的开销，如果在同一块中转移，我们最多需要走O(n^0.5)步，要走O(n)次；如果在块间转移，我们最多走O(n)步，要走O(n^0.5)次。总的O(n^1.5)

第二部分：(u,v)中v改变造成的开销，同一块中的所有点总的开销是O(n)（同一块中的v是按dfs序排的序），有O(n^0.5)块，所以是O(n^1.5)；不同块间走O(n^0.5)次，每次O(n)，总的也是O(n^1.5)

所以总的是O（n^1.5)。

这题没说m的范围，开成和n一样要RE，记得开成它的两倍。

 /**************************************************************
     Problem: 3757
     User: idy002
     Language: C++
     Result: Accepted
     Time:17840 ms
     Memory:16640 kb
 ****************************************************************/

 #include <cstdio>
 #include <cmath>
 #include <vector>
 #include <algorithm>
 #define P(p) (1<<(p))
 #define maxn 100010
 #define maxp 15
 using namespace std;

 int n, m;
 int root;
 vector<int> g[maxn];
 int stat[maxn], clr[maxn], cnt[maxn], clr_tot;
 int anc[maxn][maxp+], depth[maxn], dfn[maxn], dfs_clock;
 int mccno[maxn], mcc_len, mcc_tot;
 int ans[maxn];

 struct Qu {
     int u, v, id;
     int a, b;
     bool operator<( const Qu & c ) const {
         return mccno[u]<mccno[c.u] || ( mccno[u]==mccno[c.u] && dfn[v]<dfn[c.v] );
     }
 };
 Qu qry[maxn];

 void dfs( int u, int fa, vector<int> &remain ) {
     dfn[u] = ++dfs_clock;
     anc[u][] = fa;
     for( int p=; p<=maxp; p++ )
         anc[u][p] = anc[anc[u][p-]][p-];
     depth[u] = depth[fa]+;
     vector<int> cur;
     for( int t=; t<g[u].size(); t++ ) {
         int v = g[u][t];
         if( v==fa ) continue;
         dfs(v,u,cur);
         if( cur.size()>mcc_len ) {
             mcc_tot++;
             while( !cur.empty() ) {
                 mccno[ cur.back() ] = mcc_tot;
                 cur.pop_back();
             }
         }
     }
     while( !cur.empty() ) {
         remain.push_back( cur.back() );
         cur.pop_back();
     }
     remain.push_back(u);
 }

 int lca( int u, int v ) {
     if( depth[u]<depth[v] ) swap(u,v);
     int t = depth[u]-depth[v];
     for( int p=maxp; p>= && t; p-- )
         if( t&(P(p)) ) u = anc[u][p];
     if( u==v ) return u;
     for( int p=maxp; p>= && anc[u][]!=anc[v][]; p-- )
         if( anc[u][p]!=anc[v][p] ) u = anc[u][p], v = anc[v][p];
     return anc[u][];
 }

 void inv_sig( int u ) {
     int c = clr[u];
     int d = stat[u] ? - : ;
     stat[u] ^= ;
     if( cnt[c]== ) clr_tot++;
     cnt[c] += d;
     if( cnt[c]== ) clr_tot--;
 }
 void inverse( int u, int v ) {  //  inverse T(u,v)
     int ca = lca(u,v);
     for( ; u!=ca; u=anc[u][] )
         inv_sig(u);
     for( ; v!=ca; v=anc[v][] )
         inv_sig(v);
 }
 void calc( int q ) {
     inverse( qry[q-].u, qry[q].u );
     inverse( qry[q-].v, qry[q].v );
     int ca = lca( qry[q].u, qry[q].v );

     inv_sig( ca );
     ans[qry[q].id] = clr_tot;
     if( qry[q].a != qry[q].b && cnt[qry[q].a] && cnt[qry[q].b]  )
         ans[qry[q].id]--;
     inv_sig( ca );
 }

 int main() {
     scanf( "%d%d", &n, &m );
     mcc_len = (int)sqrt(n+);
     for( int i=; i<=n; i++ )
         scanf( "%d", clr+i );
     for( int i=,u,v; i<=n; i++ ) {
         scanf( "%d%d", &u, &v );
         if( u== ) root=v;
         if( v== ) root=u;
         if( u&&v ) {
             g[u].push_back( v );
             g[v].push_back( u );
         }
     }
     for( int i=; i<=m; i++ ) {
         scanf( "%d%d%d%d", &qry[i].u, &qry[i].v, &qry[i].a, &qry[i].b );
         qry[i].id = i;
     }

     vector<int> remain;
     dfs( root, root, remain );
     while( remain.size() ) {
         mccno[ remain.back() ] = mcc_tot;
         remain.pop_back();
     }

     sort( qry+, qry++m );

     qry[].u = qry[].v = qry[].u;
     for( int i=; i<=m; i++ )
         calc(i);
     for( int i=; i<=m; i++ )
         printf( "%d\n", ans[i] );
 }

(代码巨慢，应该是分块时拖下来的）