And And And (西安邀请赛 点分治 或 树形DP）

题目

https://nanti.jisuanke.com/t/39277

题意

求所有对于一条异或和为0的链有多少条链包含的这条链 

即 如果x 到 y 异或和为0 那么统计所有包含x-y的路径 

找到所有x - y 求和

思路

树上路径问题 点分治

预处理每个结点有多少后继结点 ： 随便选一个点为根 统计字数结点数和记录父亲

其他看代码吧

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const ll inf = 10000000;
const ll maxn = 100010;
const ll mod=1000000007;
ll n,m;
struct node
{
    ll v,nxt;
    ll dis; 
}E[maxn*4];
struct nodee //记录字数结点信息
{
    ll id,dis; //节点编号 到根节点异或值
}rem[maxn];
unordered_map<ll,ll> mp; //桶
ll tot,head[maxn];
ll maxp[maxn],size[maxn];//当前节点最大子树节点数
ll dis[maxn],judge[maxn]; //根节点当当前节点长度 当前根节点到某子树所以子节点长度 当前根节点之前所以子树出现的长度
ll vis[maxn];//当前节点是否已被分治
ll test[maxn],q[maxn];//记录答案 记录出现的长度
ll sum,rt;  //求重心变量 即当前子树节点数 当前最优重心 
ll pre[maxn];   //预处理时i节点的父亲
ll siz[maxn];  //预处理时i的子树节点
ll faa[maxn]; //选取某结点是i的父亲
ll ans;
void add(ll u,ll v,ll dis) //建图
{
    E[++tot].nxt = head[u];
    E[tot].v = v;
    E[tot].dis = dis;
    head[u] = tot;
}
void dfs(ll x,ll fa) //预处理
{
    siz[x] = 1;
    pre[x] = fa;
    for(ll i = head[x];i != -1;i=E[i].nxt)
    {
        ll v = E[i].v;
        if(v != fa)
        {
            dfs(v,x);
            siz[x] += siz[v];
        }
    }
}

void getrt(ll u,ll pa) //查询重心
{
    size[u] = 1;
    maxp[u] = 0;
    for(ll i = head[u];i != -1;i = E[i].nxt)
    {
        ll v = E[i].v;
        if(v == pa||vis[v]) continue;
        getrt(v,u);
        size[u] += size[v];
        maxp[u] = max(maxp[u],size[v]);
    }
    maxp[u] = max(maxp[u],sum-size[u]);
    if(maxp[u] < maxp[rt]) rt = u;
}

void getdis(ll u,ll fa) //统计当前子树到根节点信息
{
    rem[++rem[0].dis].dis = dis[u]; 
    rem[rem[0].dis].id = u;
    faa[u] = fa; //记录此节点父亲
    for(ll i = head[u];i != -1;i=E[i].nxt)
    {
        ll v = E[i].v;
        if(v == fa||vis[v]) continue;
        dis[v] = dis[u] ^ E[i].dis;
        getdis(v,u);
    }
}

void calc(ll u) //以u为根所有路径包含u的答案
{
    mp.clear(); //清空桶
    ll p = 0;
    for(ll i = head[u];i != -1;i=E[i].nxt) //计算所有子树
    {
        ll v = E[i].v;
        if(vis[v]) continue;
        rem[0].dis = 0;
        dis[v] = E[i].dis;
        getdis(v,u);
        for(ll j = rem[0].dis;j >= 1;j--) //计算当前子树
        {
            if(faa[rem[j].id] == pre[rem[j].id]) //以u为节点为根节点和预处理是父亲一致 说明u在v预处理的子树
            {                                       //上，那么他的后继结点数量就是预处理是子树结点数量
                ans += siz[rem[j].id]%mod*mp[rem[j].dis]%mod;
                if(rem[j].dis == 0) //如果异或值为0 要加上以根节点为链的答案
                {
                    if(pre[v] == u) ans += siz[rem[j].id]%mod*(n-siz[v])%mod; //自己画图想吧
                    else ans += siz[rem[j].id]%mod*(siz[u])%mod;
                }
                ans %= mod;
            }
            else 
            {
                ans += (n-siz[faa[rem[j].id]])%mod*mp[rem[j].dis]%mod; //自己画图想吧
                if(rem[j].dis == 0)
                {
                    if(pre[v] == u) ans += (n-siz[faa[rem[j].id]])%mod*(n-siz[v])%mod;
                    else ans += (n-siz[faa[rem[j].id]])%mod*(siz[u])%mod;
                }
                ans %= mod;
            }
        }
        for(ll j = rem[0].dis;j >= 1;j--)//把当前子树节点信息与之前合并
        {
            if(faa[rem[j].id] == pre[rem[j].id])
            {
                mp[rem[j].dis] += siz[rem[j].id];
            }
            else
            {
                mp[rem[j].dis] += (n-siz[faa[rem[j].id]]);
            }
            mp[rem[j].dis] %= mod;
        }
    }
}

void solve(ll u) //分治
{
    vis[u] = judge[0] = 1;
    calc(u);
    for(ll i = head[u];i != -1;i = E[i].nxt)
    {
        ll v = E[i].v;
        if(vis[v]) continue;
        sum = size[v],maxp[rt = 0] = inf;
        getrt(v,0),solve(rt);
    }
}

int main()
{
    memset(head,-1,sizeof(head));
    tot = 0;
    scanf("%lld",&n);
    for(ll i = 2;i <= n;i++) // 建图
    {
        ll u,v,dis;
        scanf("%lld%lld",&u,&dis);
        v = i;
        add(u,v,dis),add(v,u,dis);
    }
    dfs(1,0);
    ans = 0;
    maxp[rt] = sum = n;
    getrt(1,0); //求重心
    memset(vis,0,sizeof(vis));
    solve(rt);//开始分治
    ans %= mod;
    printf("%lld\n",ans);
    return 0;
}

参考博客

https://blog.csdn.net/ccsu_cat/article/details/90607753

思路

异或的性质 可以抵消，比如从x y z在一条链上，x到y异或为3 x到z异或为3 那么y到z异或为0

先dfs统计每个子树的节点数 然后在dfs统计答案 

在统计某个子树时 这个节点的后继节点n为 n-size[i] 统计完后要去掉

在统计其他子树时 前一个子树节点后继节点为 size[i] 

具体看代码

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const ll maxn = 100005;
const ll mod = 1000000007;
unordered_map<ll,ll> mp;
struct node
{
    ll v,nxt,dis;
}e[maxn<<1];
ll sz[maxn];
ll head[maxn],top;
ll ans;
ll num[maxn];
ll n;
void add(ll u,ll v,ll w)
{
    e[top].v = v;
    e[top].dis = w;
    e[top].nxt = head[u];
    head[u] = top++;
}
void dfs(ll u,ll fa) //父亲节点没用到 懒得改了
{
    sz[u] = 1;
    for(ll i = head[u];i != -1;i = e[i].nxt)
    {
        ll v = e[i].v;
        num[v] = num[u] ^ e[i].dis;
        dfs(v,u);
        sz[u] += sz[v];
    }
}
void dfs2(ll u)
{
    ans = (ans + sz[u]*mp[num[u]])%mod; //统计答案
    for(int i = head[u];i != -1;i = e[i].nxt)
    {
        int v = e[i].v;
        mp[num[u]] = (mp[num[u]] + n - sz[v])%mod; //把这个点的贡献加入桶
        dfs2(v);
        mp[num[u]] = (mp[num[u]] - n + sz[v])%mod; //统计完他的子树 去掉贡献
    }
    mp[num[u]] = (mp[num[u]] + sz[u])%mod; //统计其他子树 贡献为size[i]
}
int main()
{
    scanf("%lld",&n);
    memset(head,-1,sizeof(head));
    top = 0;
    for(ll i = 2;i <= n;i++)
    {
        ll u,w;
        scanf("%lld%lld",&u,&w); 
        add(u,i,w);//这里不需要换根 所以只记录单向边即可
    }
    num[1] = 0;
    dfs(1,0);
    ans = 0;
    dfs2(1);
    printf("%lld\n",ans);
    return 0;
}