[BZOJ3772]精神污染主席树上树+欧拉序

3772: 精神污染

Time Limit: 10 Sec Memory Limit: 64 MB

Description

兵库县位于日本列岛的中央位置，北临日本海，南面濑户内海直通太平洋，中央部位是森林和山地，与拥有关西机场的大阪府比邻而居，是关西地区面积最大的县，是集经济和文化于一体的一大地区，是日本西部门户，海陆空交通设施发达。濑户内海沿岸气候温暖，多晴天，有日本少见的贸易良港神户港所在的神户市和曾是豪族城邑“城下町”的姬路市等大城市，还有以疗养地而闻名的六甲山地等。

兵库县官方也大力发展旅游，为了方便，他们在县内的N个旅游景点上建立了n-1条观光道，构成了一棵图论中的树。同时他们推出了M条观光线路，每条线路由两个节点x和y指定，经过的旅游景点就是树上x到y的唯一路径上的点。保证一条路径只出现一次。

你和你的朋友打算前往兵库县旅游，但旅行社还没有告知你们最终选择的观光线路是哪一条（假设是线路A）。这时候你得到了一个消息：在兵库北有一群丧心病狂的香菜蜜，他们已经选定了一条观光线路（假设是线路B），对这条路线上的所有景点都释放了【精神污染】。这个计划还有可能影响其他的线路，比如有四个景点1-2-3-4，而【精神污染】的路径是1-4，那么1-3,2-4,1-2等路径也被视为被完全污染了。

现在你想知道的是，假设随便选择两条不同的路径A和B，存在一条路径使得如果这条路径被污染，另一条路径也被污染的概率。换句话说，一条路径被另一条路径包含的概率。

Input

第一行两个整数N,M

接下来N-1行，每行两个数a,b，表示A和B之间有一条观光道。

接下来M行，每行两个数x,y，表示一条旅游线路。

Output

所求的概率，以最简分数形式输出。

Sample Input

5 3
1 2
2 3
3 4
2 5
3 5
2 5
1 4

Sample Output

1/3
样例解释
可以选择的路径对有(1,2),(1,3),(2,3)，只有路径1完全覆盖路径2。

HINT

100%的数据满足：N,M<=100000

题解：

这道题真是精神污染……

首先，最重要的，本题卡内存，建议用数组打/开内存池重载new

接下来，我们来分析题目：一条路径被另一条路径包含的概率，等于包含的情况数除以所有路径组合。

即SUM/C(n)(2)。现在的问题转变为求SUM。

不难发现，如果一条路径A被一条路径B包含，那么A的两端点都在B内。

所以对于B路径，它包含路径的条数可以通过下面的方法求：枚举路径上的每一个点，看从这个点出发的路径有几条的终点也在B内。

这时候我们就需要一种区间可减的数据结构来维护信息……

显然是主席树，然后用欧拉序（似乎叫括号序更恰当）统计。不了解的同学可以去我之前的博客找一波讲解。

不过注意，对于本题来说，由于我们统计的是边，所以我们应该统计[x.lca]和[y.lca]。

lca处的答案被统计了2次，最后记得减去；并且，自己不能覆盖自己，统计完之后还要-1才行。

这样本题就被我们解决了:) 代码见下：

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #include <vector>

 using namespace std;

 typedef long long LL;

 const int N=;

 vector<int>vec[N];

 int n,m,num,deep[N],adj[N],e,l[N],r[N];

 struct edge{int zhong,next;}s[N<<];

 inline void add(int qi,int zhong){s[++e].zhong=zhong;s[e].next=adj[qi];adj[qi]=e;}

 struct data{int qi,zhong;}ro[N];

 inline bool mt(const data &a,const data &b){return (a.qi==b.qi)?a.zhong<b.zhong:a.qi<b.qi;}

 struct node

 {

     node *ch[];int cnt;

     void* operator new (size_t,node *a,node *b,int c)

     {

         static node mempool[N*],*C=mempool;

         C->ch[]=a,C->ch[]=b,C->cnt=c;

         return C++;

     }

     node* insert(int l,int r,int pos,int val)

     {

         if(l==r)return new (NULL,NULL,this->cnt+val)node;

         int mi=(l+r)>>;

         if(pos<=mi) return new (ch[]->insert(l,mi,pos,val),ch[],this->cnt+val)node;

         else return new (ch[],ch[]->insert(mi+,r,pos,val),this->cnt+val)node;

     }

 }*root[N];

 int query(node *a,node *b,node *c,node *d,int le,int ri,int L,int R)

 {

     if(L<=le&&ri<=R)return a->cnt+b->cnt-c->cnt-d->cnt;

     int ret=,mi=(le+ri)>>;

     if(L<=mi)ret+=query(a->ch[],b->ch[],c->ch[],d->ch[],le,mi,L,R);

     if(mi<R)ret+=query(a->ch[],b->ch[],c->ch[],d->ch[],mi+,ri,L,R);

     return ret;

 }

 int f[N][],bin[];

 inline int LCA(int a,int b)

 {

     if(deep[a]<deep[b])swap(a,b);

     int cha=deep[a]-deep[b];

     for(int j=;~j;j--)

         if(cha&bin[j])a=f[a][j];

     if(a==b)return a;

     for(int j=;~j;j--)

         if(f[a][j]!=f[b][j])a=f[a][j],b=f[b][j];

     return f[a][];

 }

 void dfs1(int rt,int fa)

 {

     l[rt]=++num;deep[rt]=deep[fa]+;

     for(int i=adj[rt];i;i=s[i].next)

         if(s[i].zhong!=fa)f[s[i].zhong][]=rt,dfs1(s[i].zhong,rt);

     r[rt]=++num;

 }

 void dfs2(int rt,int fa)

 {

     root[rt]=root[fa];

     for(int i=,len=vec[rt].size();i<len;i++)

     {

         root[rt]=root[rt]->insert(,n<<,l[vec[rt][i]],);

         root[rt]=root[rt]->insert(,n<<,r[vec[rt][i]],-);

     }

     for(int i=adj[rt];i;i=s[i].next)

         if(s[i].zhong!=fa)dfs2(s[i].zhong,rt);

 }

 LL Z,M;

 LL gcd(LL a,LL b){return (b==)?a:gcd(b,a%b);}

 int main()

 {

     scanf("%d%d",&n,&m);int a,b;

     for(int i=;i<n;i++)scanf("%d%d",&a,&b),add(a,b),add(b,a);

     for(int i=;i<=m;i++)

         scanf("%d%d",&ro[i].qi,&ro[i].zhong),vec[ro[i].qi].push_back(ro[i].zhong);

     root[]=new (NULL,NULL,) node;

     root[]->ch[]=root[]->ch[]=root[];

     dfs1(,);dfs2(,);

     bin[]=;for(int i=;i<=;i++)bin[i]=bin[i-]<<;

     for(int j=;j<=;j++)

         for(int i=;i<=n;i++)

             f[i][j]=f[f[i][j-]][j-];

     for(int i=;i<=m;i++)

     {

         int lca=LCA(ro[i].qi,ro[i].zhong),t=f[lca][];

         a=ro[i].qi,b=ro[i].zhong;

         Z+=query(root[a],root[b],root[lca],root[t],,n<<,l[lca],l[a]);

         Z+=query(root[a],root[b],root[lca],root[t],,n<<,l[lca],l[b]);

         Z-=query(root[a],root[b],root[lca],root[t],,n<<,l[lca],l[lca]);

         Z--;

     }

     M=(LL)m*(m-)>>;LL tmp=gcd(Z,M);

     printf("%lld/%lld",Z/tmp,M/tmp);

 }