MC0362异或 （码蹄集星耀难度题型）

此题涉及：算法基础：前缀和 | 差分图论：树上问题数学：位运算

码蹄集OJ-异或 

一、讨论区较为简介清晰代码 ：

const int mod = 1e9 + 7, N = 5e5 + 5;
int a[N], f[N][30][2];
vector<int> g[N], st;
int n, q, k;
void dfs(int i, int fa) {
    st.push_back(i);
    for (int j = 0; j < 30; j++) {
        f[i][j][(a[i] >> j) & 1]++;
        f[st[max(0, (int)st.size() - k - 2)]][j][(a[i] >> j) & 1]--;
    }
    for (auto x : g[i]) {
        if (x == fa) continue;
        dfs(x, i);
    }
    st.pop_back();
}
void dfs_sum(int i, int fa) {
    for (auto x : g[i]) {
        if (x == fa) continue;
        dfs_sum(x, i);
        for (int j = 0; j < 30; j++) {
            f[i][j][0] += f[x][j][0];
            f[i][j][1] += f[x][j][1];
        }
    }
}
int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin >> n >> q >> k;
    for (int i = 1; i <= n; i++) cin >> a[i];
    g[0].push_back(1);
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(0, 0);
    dfs_sum(0, 0);
    for (int i = 1; i <= q; i++) {
        int x;
        cin >> x;
        long long ans = 0;
        for (int i = 0; i < 30; i++) {
            ans = (ans + 1ll * f[x][i][0] * f[x][i][1] % mod * (1 << i) % mod) % mod;
        }
        cout << ans << '\n';
    }
    return 0;
}

 这段代码为最终的精炼代码，多开一个0节点将

if ((int)st.size() - k > 1)  //这儿有巨坑---size类型是size_t 不存在负数
        {
            f[st[st.size() - 1 - k - 1]][j][(a[x] >> j) & 1]--;
        }

换为（提速）

f[st[max(0, (int)st.size() - k - 2)]][j][(a[i] >> j) & 1]--;

二、我的代码：

#include<bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 5e5 + 10; const int mod = 1e9 + 7;
int n, q, k;
int f[N][30][2];
int a[N];//存储每个节点的权值
vector<int>edges[N], st;
void dfs(int x, int fx)//节点x和节点x的根节点
{
    st.push_back(x);
    for (int j = 0; j < 30; j++)
    {
        f[x][j][(a[x] >> j) & 1]++;
        //超过k层时要 间隔--操作，原因：后续dfs_sum会加上所有的和，但此题有层数限制
        //这么写会比讨论区那个代码慢：会慢条件判断（5e5*30）
        if ((int)st.size() - k > 1)  //这儿有巨坑---size类型是size_t 不存在负数
        {
            f[st[st.size() - 1 - k - 1]][j][(a[x] >> j) & 1]--;
        }
    }

    for (auto i : edges[x])
    {
        if (i == fx)continue;
        dfs(i, x);
    }
    st.pop_back();//必须回溯
}

void dfs_sum(int x, int fx)
{
    for (auto i : edges[x])
    {
        if (i == fx)continue;
        dfs_sum(i, x);
        for (int j = 0; j < 30; j++)
        {
            f[x][j][0] += f[i][j][0];
            f[x][j][1] += f[i][j][1];
        }
    }

}

int main()
{
    cin.tie(0)->sync_with_stdio(0);//提速
    cin >> n >> q >> k;
    for (int i = 1; i <= n; i++)cin>>a[i];
    for (int i = 1; i <= n - 1; i++)
    {
        int a, b; cin >> a >> b;
        //无法确定根的顺序，所以存储双向
        edges[a].push_back(b);
        edges[b].push_back(a);
    }

    dfs(1, 1);
    dfs_sum(1, 1);

    while (q--)
    {
        int x; cin >> x;
        long long ret = 0;
        for (int j = 0; j < 30; j++)
        {
            ret = (ret + (1ll * f[x][j][0] * f[x][j][1]%mod * (1 << j)) % mod) % mod;
        }
        cout << ret << endl;
    }
    return 0;
}

思路：暴力枚举明显超时。将每个节点的权值差分成二进制位进行存储，记录每一位下的0和1的总个数,每一位分别异或（结果便是该位下0的个数和1的个数的乘积）再乘以1<<该位次，时间复杂度：n*30

f[N][30][2] N个节点，30个二进制位（最大的数小于1e9），0和1的个数记录

步骤：初始化（存权值、存图）-->dfs(记录每一个节点的二进制位，但有层数限制，要减去后续会多加的层数的权值（二进制位）)-->dfs_sum(求每一个节点的异或和，dfs时已处理过多加的情况，此处直接累加即可)-->%mod的位置一定要注意（一定要避免出现负数）

三、上述代码注意事项：

1、巨坑---vector的size()类型为size_t 不存在负数，一定要强转类型再做判断

if ((int)st.size() - k > 1)  //这儿有巨坑---size类型是size_t 不存在负数

2、第二段代码回避第一段代码慢：亲测慢在条件判断（5e5*30）

//这么写会比讨论区那个代码慢：会慢条件判断（5e5*30）
        if ((int)st.size() - k > 1)  //这儿有巨坑---size类型是size_t 不存在负数
        {
            f[st[st.size() - 1 - k - 1]][j][(a[x] >> j) & 1]--;
        }

这个减操作必须要有，在后续dfs_sum求和时 较难实现去重求和，故而在dfs时变顺便实现减重操作