[BZOJ3772]精神污染（主席树）

题目：

我是超链接

题解：

明明不是很难的题，我想了好久啊

我们可以选择求一条路径覆盖了多少路，也可以求一条路被多少路径覆盖，我采用的是前者【一条路径覆盖了多少路】
其实我们有一个想法是统计这条路径上有多少个【路径结束点】，想办法消除【路径开始点】的影响，这就是我们覆盖的路径数量

消除【路径开始点】，可以通过外层顺序是dfs序解决，只要我们先建立那些dfs序小（浅）的节点，因为在建立的时候才添加【开始点】对应的【结束点】，所以那些结束点在内，开始点不在内的，结束点根本没有机会添加进去╮(╯▽╰)╭
可以建立一棵树上主席树，维护当前点到根的信息，内层是dfs序，对于同一个节点，我们只需要关注【路径结束点】，当【结束点】in的时候+1，【结束点】out的时候-1。
你想啊，如果你统计子树的时候发现了【结束点】但ta又走了，这不就代表ta根本不在你想要的路径上啊，走就走了呗，只有那些【结束点】in才是我们需要的在路径上的点
当我们要查询的时候，把这条路径砍成两半【in[lca]，in[x]】【in[lca]，in[y]】，诶这样一看我们不就把x-lca上的【结束点】个数记录下来了嘛，但是【in[lca]，in[lca]】是重合的部分，要减去啊，再加上自己覆盖自己的路径，还要- -

处理细节就是我们必须给每个in[i],out[i]都留一个空间，不然的话，对于一个路径【结束点】，如果ta当时就出去了（in[i]=out[i]），这个结束点就不会算在内，但其实ta要被算在内呀

代码：

#include <vector>
#include <cstdio>
#include <algorithm>
#define LL long long
using namespace std;
const int mc=18;
const int N=100005;
struct hh{int l,r,sum;}t[N*39];
struct ask{int x,y;}q[N];
int tot,nxt[N*2],point[N],v[N*2],f[N][20],mi[20],nn,in[N],out[N],h[N],sz,root[N],n;
vector<int>g[N];
LL gcd(LL a,LL b){if (!b) return a;else return gcd(b,a%b);}
void addline(int x,int y)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x;
}
void dfs(int x,int fa)
{
    in[x]=++nn; h[x]=h[fa]+1;
    for (int i=1;i<mc;i++)
      if (h[x]-mi[i]<1) break;
      else f[x][i]=f[f[x][i-1]][i-1];
    for (int i=point[x];i;i=nxt[i])
      if (v[i]!=fa)
      {
        f[v[i]][0]=x;
        dfs(v[i],x);
      }
    out[x]=++nn;
}
int lca(int x,int y)
{
    if (h[x]<h[y]) swap(x,y);
    int k=h[x]-h[y]; 
    for (int i=0;i<mc;i++)
      if (k&(1<<i)) x=f[x][i];
    if (x==y) return x;
    for (int i=mc-1;i>=0;i--)
      if (f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];
}
void insert(int &now,int l,int r,int x,int v)
{
    t[++sz]=t[now]; now=sz;
    t[now].sum+=v;
    if (l==r) return;
    int mid=(l+r)>>1;
    if (x<=mid) insert(t[now].l,l,mid,x,v);
    else insert(t[now].r,mid+1,r,x,v);
}
void build(int x)
{
    root[x]=root[f[x][0]];
    for (int i=0;i<g[x].size();i++)
    {
        insert(root[x],1,nn,in[g[x][i]],1);
        insert(root[x],1,nn,out[g[x][i]],-1);
    }
    for (int i=point[x];i;i=nxt[i])
      if (v[i]!=f[x][0]) build(v[i]);
}
LL qurry(int x,int y,int fa,int old,int l,int r,int lrange,int rrange)
{
    if (lrange<=l && rrange>=r) return t[x].sum+t[y].sum-t[fa].sum-t[old].sum;
    int mid=(l+r)>>1; LL ans=0;
    if (lrange<=mid) ans+=qurry(t[x].l,t[y].l,t[fa].l,t[old].l,l,mid,lrange,rrange);
    if (rrange>mid) ans+=qurry(t[x].r,t[y].r,t[fa].r,t[old].r,mid+1,r,lrange,rrange);
    return ans;
}
int main()
{
    int m;
    mi[0]=1;
    for (int i=1;i<mc;i++) mi[i]=mi[i-1]*2;
    scanf("%d%d",&n,&m);
    for (int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        addline(x,y);
    }
    dfs(1,0);
    for (int i=1;i<=m;i++) scanf("%d%d",&q[i].x,&q[i].y),g[q[i].x].push_back(q[i].y);
    build(1);
    LL ans=0;
    for (int i=1;i<=m;i++)
    {
        int fa=lca(q[i].x,q[i].y);
        int t1=root[q[i].x],t2=root[q[i].y],t3=root[fa],t4=root[f[fa][0]];
        ans+=qurry(t1,t2,t3,t4,1,nn,in[fa],in[q[i].x])+qurry(t1,t2,t3,t4,1,nn,in[fa],in[q[i].y])-qurry(t1,t2,t3,t4,1,nn,in[fa],in[fa])-1;
    }
    LL tmp=gcd(ans,(LL)m*(m-1)/2);
    printf("%lld/%lld",ans/tmp,(LL)m*(m-1)/2/tmp);
}

总结：

对于这种两重限制的东西就可以试着用主席树来解决，因为主席树记录根节点的root数组可以搞一个限制，内层线段树还可以搞一个限制。这里的每一重限制因为都是路径上的，所以需要用树上主席树来搞。