BZOJ4568: [Scoi2016]幸运数字【线性基】

最新推荐文章于 2020-10-26 11:20:52 发布

Hacb

最新推荐文章于 2020-10-26 11:20:52 发布

阅读量346

点赞数

CC 4.0 BY-SA版权

分类专栏：线性基树链剖分 lca 文章标签：线性基-树链剖分

本文链接：https://blog.youkuaiyun.com/u010089558/article/details/78392784

线性基同时被 3 个专栏收录

1 篇文章

订阅专栏

树链剖分

1 篇文章

订阅专栏

lca

1 篇文章

订阅专栏

本文介绍了一种结合树链剖分与线性基的数据结构算法，用于解决特定类型的路径最大异或值查询问题。通过树链剖分预处理树状结构，并利用线性基快速计算节点间路径的最大异或值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这题需要用到线性基的知识，首先先介绍一下线性基（参考博客http://www.cnblogs.com/ljh2000-jump/p/5869991.html）。

线性基就是一组数 $a_{1}, a_2, ..., a_n$ ，其中 $a_x$ 的最高位的1在第 $x$ 位。
线性基中没有0。
假设集合 $A$ 的一组线性基 $B$ ，则 $B$ 中由xor生成的集合 $C$ 和 $A$ 所生成的集合相同。

线性基的构造方式：给定集合 $A$ ，对于 $A$ 中的每一个数 $p$ ，从最高位开始扫描，扫到第 $x$ 位为1时，若 $a_x$ 不存在，则 $a_x = p$ ，否则 $p = p~xor~a_x$ 。

以下是这道题的树链剖分+线性基的做法

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define N 20003
#define B 61
#define mid (l+r>>1)
#define lc (d<<1)
#define rc (d<<1|1)
typedef long long ll;

vector<int> E[N];
int dep[N], fa[N], top[N], dfn[N], tid[N], son[N], cnt[N], tot;
ll val[N];

void dfs(int u, int f) {
    int i, v;
    son[u] = u, cnt[u] = 1, fa[u] = f;
    for (i = 0;i < E[u].size();i++) {
        v = E[u][i];
        if (v == f) continue;
        dfs(v, u);
        cnt[u] += cnt[v];
        if (son[u] == u || cnt[v] > cnt[son[u]]) son[u] = v;
    }
}

void dfs1(int u, int Top, int d) {
    int i, v;
    dep[u] = d, dfn[u] = ++tot;
    tid[tot] = u, top[u] = Top;
    if (dfn[son[u]] == -1) dfs1(son[u], Top, d+1);
    for (i = 0;i < E[u].size();i++) {
        v = E[u][i];
        if (dfn[v] != -1) continue;
        dfs1(v, v, d+1);
    }
}

struct Basic {
    ll a[B];
    Basic(){}
    Basic(ll p) {
        init();
        add(p);
    }
    void init() {
        memset(a, 0, sizeof(a));
    }
    void add(ll p) {
        for (int i = B-1;i >= 0 && p;i--) {
            if (p&(1LL<<i)) {
                if (!a[i]) {
                    a[i] = p;
                    break;
                }
                else p ^= a[i];
            }
        }
    }
    Basic operator + (Basic o) const {
        Basic re;
        memcpy(re.a, a, sizeof(a));
        for (int i = 0;i < B;i++) {
            re.add(o.a[i]);
        }
        return re;
    }
    ll getMax() {
        ll re = 0;
        for (int i = B-1;i >= 0;i--) {
            if (re < (re^a[i])) re ^= a[i];
        }
        return re;
    }
}tr[N<<2];

void build(int d, int l, int r) {
    if (l == r) {
        tr[d] = Basic(val[tid[l]]);
        return;
    }
    build(lc, l, mid);
    build(rc, mid+1, r);
    tr[d] = tr[lc]+tr[rc];
}

Basic query(int d, int l, int r, int L, int R) {
    if (l == L && r == R) {
        return tr[d];
    }
    if (R <= mid) return query(lc, l, mid, L, R);
    else if (L > mid) return query(rc, mid+1, r, L, R);
    else return query(lc, l, mid, L, mid)+query(rc, mid+1, r, mid+1, R);
}

ll query(int u, int v) {
    Basic re;
    re.init();
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        re = re+query(1, 1, tot, dfn[top[u]], dfn[u]);
        u = fa[top[u]];
    }
    if (dfn[u] > dfn[v]) swap(u, v);
    re = re+query(1, 1, tot, dfn[u], dfn[v]);
    return re.getMax();
}

int in() {
    char c = getchar();
    int re = 0;
    while (c > '9' || c < '0') c = getchar();
    while (c >= '0' && c <= '9') {
        re = re*10+c-'0';
        c = getchar();
    }
    return re;
}

int main() {
    int n, q, u, v, i, j;
    while (~scanf("%d%d", &n, &q)) {
        for (i = 1;i <= n;i++) {
            scanf("%lld", val+i);
            E[i].clear();
        }
        tot = 0;
        for (i = 1;i < n;i++) {
            u = in(), v = in();//scanf("%d%d", &u, &v);
            E[u].push_back(v);
            E[v].push_back(u);
        }
        memset(dfn, -1, sizeof(dfn));
        dfs(1, 0);
        dfs1(1, 1, 0);
        build(1, 1, n);
        while (q--) {
            u = in(), v = in();//scanf("%d%d", &u, &v);
            printf("%lld\n", query(u, v));
        }
    }
}

接下来是复杂度降了一个log的lca+线性基的做法：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define N 20003
#define B 61
#define mid (l+r>>1)
#define lc (d<<1)
#define rc (d<<1|1)
typedef long long ll;

vector<int> E[N];
int dep[N], fa[N][16];
ll val[N];

struct Basic {
    ll a[B];
    Basic(){}
    Basic(ll p) {
        init();
        add(p);
    }
    void init() {
        memset(a, 0, sizeof(a));
    }
    void add(ll p) {
        for (int i = B-1;i >= 0 && p;i--) {
            if (p&(1LL<<i)) {
                if (!a[i]) {
                    a[i] = p;
                    break;
                }
                else p ^= a[i];
            }
        }
    }
    void operator += (Basic o) {
        for (int i = 0;i < B;i++) {
            add(o.a[i]);
        }
    }
    ll getMax() {
        ll re = 0;
        for (int i = B-1;i >= 0;i--) {
            if (re < (re^a[i])) re ^= a[i];
        }
        return re;
    }
}dp[N][16];

void dfs(int u, int f, int d) {
    dep[u] = d;
    fa[u][0] = f;
    dp[u][0] = Basic(val[f]);
    int i, v;
    for (i = 1;i < 16;i++) {
        fa[u][i] = fa[fa[u][i-1]][i-1];
        dp[u][i] = dp[u][i-1];
        dp[u][i] += dp[fa[u][i-1]][i-1];
    }
    for (i = 0;i < E[u].size();i++) {
        v = E[u][i];
        if (v == f) continue;
        dfs(v, u, d+1);
    }
}

ll query(int u, int v) {
    Basic re;
    if (dep[u] < dep[v]) swap(u, v);
    re = Basic(val[u]);
    int i;
    for (i = 15;i >= 0;i--) {
        if (dep[v] <= dep[fa[u][i]]) {
            re += dp[u][i];
            u = fa[u][i];
        }
    }
    if (u != v) {
        re += Basic(val[v]);
        for (i = 15;i >= 0;i--) {
            if (fa[v][i] != fa[u][i]) {
                re += dp[u][i];
                re += dp[v][i];
                u = fa[u][i];
                v = fa[v][i];
            }
        }
        re += dp[u][0];
    }
    return re.getMax();
}

int in() {
    char c = getchar();
    int re = 0;
    while (c > '9' || c < '0') c = getchar();
    while (c >= '0' && c <= '9') {
        re = re*10+c-'0';
        c = getchar();
    }
    return re;
}

int main() {
    int n, q, u, v, i, j;
    while (~scanf("%d%d", &n, &q)) {
        for (i = 1;i <= n;i++) {
            scanf("%lld", val+i);
            E[i].clear();
        }
        for (i = 1;i < n;i++) {
            u = in(), v = in();//scanf("%d%d", &u, &v);
            E[u].push_back(v);
            E[v].push_back(u);
        }
        dfs(1, 1, 0);
        while (q--) {
            u = in(), v = in();//scanf("%d%d", &u, &v);
            printf("%lld\n", query(u, v));
        }
    }
}