More than Linear Basis

线性基 (Linear Basis)

在线性代数中, 基 (basis) (也称为基底) 是描述, 刻画向量空间的基本工具. 向量空间的基是它的一个特殊的子集, 基的元素称为基向量. 向量空间中任意一个元素, 都可以唯一地表示成基向量的线性组合. 如果基中元素个数有限, 就称向量空间为有限维向量空间, 将元素的个数称作向量空间的维数. ----Wikipedia

定义

OI 中, 线性基特指一种线性空间的基. 这种线性空间的向量的每一维坐标是 \(0\) 或 \(1\), 每维坐标可以看作整数的每个二进制位. 加法定义是按位异或, 数乘定义没有意义, 因为因数只能是 \(0\) 或 \(1\).

性质

由于线性基内所有向量线性无关. 所以线性基的大小即为线性空间中线性无关的向量个数, 不会超过 \(\log V\) 个.

如果把线性基的元素放一起形成矩阵, 进行初等变换后一定还是原线性空间的线性基. 而且我们用初等变换可以把线性基变成最高位的 \(1\) 互不相同的数集.

算法

假设现在有 \(n\) 个数, \(a_1\),..., \(a_n\), 求它们生成的线性空间 \(A\) 的基 \(B\).

我们先考虑从定义出发, 如果我们把所有给定的数字看成是行向量, 然后组成过一个 \(n\) 行 \(\log V\) 列的矩阵, 高斯消元后非全零的行即为所求的线性基. 对这个矩阵进行高斯消元的复杂度是 \(O(n^2\log V)\). 如果 \(V < 2^{64}\) 时我们可以通过用整数表示行向量来优化行异或为 \(O(1)\), 所以复杂度优化到 \(n^2\). 当 \(V\) 超出 \(8\) 字节后可以进行 bitset 优化, 达到 \(O(\frac {n^2 \log V}w)\).

可以每次插入一个行向量就进行一轮初等变换, 出现全零行就将其删除, 维持这个矩阵为已经插入的行向量生成的线性空间的基 \(B\), 并且从大到小有序排列. 每次插入一个行向量需要进行 \(O(|B|)\) 次行异或. 因为 \(|B| \leq \log V\), 所以这样总共需要 \(P(n \log V)\) 次行异或. 当 \(V < 2^{64}\) 时, 复杂度为 \(O(n \log V)\), 否则是 \(\frac {n \log^2 V}w\).

因为行向量从大到小排列, 且高斯消元使得它们最高位互不相同, 所以矩阵每行最高位不同. 对于一个新的行向量 \(a\), 从上往下扫描矩阵, 如果发现了不存在和 \(a\) 最高位相同的行向量, 那么直接把 \(a\) 插入矩阵这一行中. 如果存在, 那么使 \(a\) 被这个行向量异或. \(a\) 的最高位一定会减小, 这时继续刚才的操作, 直到把 \(a\) 作为行向量插入 \(B\) 或 \(a\) 变成 \(0\) 为止.

为了方便操作, 使得矩阵第 \(i\) 行对应最高位为 \(i\) 的行向量.

n = RD(), Bin[0] = 1;
for (unsigned i(1); i <= 50; ++i) Bin[i] = (Bin[i - 1] << 1);
for (unsigned i(1); i <= n; ++i) {
  A = RD();
  for (unsigned j(50); ~j; --j) if (A & Bin[j]) {
    if (B[j]) A ^= B[j];
    else { B[j] = A; break; }
  }
}

判断向量是否属于 \(A\)

如果把 \(x\) 插入 \(B\) 时 \(x\) 被异或成 \(0\), 说明它属于 \(A\).

求 \(A\) 中最大向量

只要从大到小枚举线性基然后贪心即可, 每一位能赋成 \(1\) 就赋成 \(1\).

for (unsigned i(50); ~i; --i) if ((B[i]) && (!(Ans & Bin[i]))) Ans ^= B[i];
printf("%llu\n", Ans);

求 \(A\) 中最小非零向量

线性基的最小元素即为最小非零向量.

求 \(A\) 中第 \(k\) 小的非零向量

我们把 \(B\) 高斯消元后, 得到的矩阵中一定能使得每一行的最高位的 \(1\) 是当前列唯一的 \(1\).

所以要想凑出线性空间中的向量 \(x\). 如果 \(x\) 中的某一位 \(1\) 是某个 \(B\) 中元素的最高位的 \(1\), 那么这个 \(1\) 只能由它提供; 如果 \(x\) 中某一位 \(0\) 是某个 \(B\) 中元素的最高位的 \(1\), 那么这个元素一定不在异或出 \(x\) 的元素集合中, 否则 \(x\) 的这一位就变成 \(1\) 了.

根据上面的规则, 只要知道 \(x\) 的所有这 \(|B|\) 个位置的值, 就可以构造出唯一的 \(x\). 所以 \(|A| = 2^{|B|}\).

\(B\) 的前 \(i\) 小的元素, 可以生成 \(2^i\) 个 \(A\) 中的元素. 因为任意这 \(2^i\) 个元素异或一个 \(B\) 中的前 \(i\) 小的元素之外的元素, 都会变大, 因此可以知道这 \(2^i\) 个元素即为 \(A\) 中最小的 \(2^i\) 个元素.

所以对于 \(k\) 来说, 如果它的最高位是第 \(i\) 位, 那么 \(A\) 中第 \(k\) 小的元素 \(Ans\) 的最高位一定等于 \(B\) 中第 \(i\) 小的元素的最高位. 然后就得到了子问题: 求 \(B\) 中前 \(i - 1\) 的元素生成的 \(2^{i - 1}\) 个元素中第 \(k - 2^i\) 小的元素 \(Ans'\). \(Ans\) 即为 \(Ans'\) 异或 \(B\) 中第 \(i\) 小元素的值. 扫描一遍 \(B\), 过程中维护 \(Ans\) 即可得到答案.

求并

我们只要把 \(B_1\) 的所有元素插入 \(B_2\) 中即可.

求交

对于两个集合 \(B \subseteq A\), 定义运算 \(A \backslash B\), 若 \(x \in (A \backslash B)\), 当且仅当 \(x \in A, x \notin B\).

我们要对 \(B_1\) 进行初等变换, 使得 \(A_2 \cap B_1\) 为 \(A_1\), \(A_2\) 的交 \(A\) 的基 \(B\). 为了构造, 建一个临时集合 \(S\), 把 \(B_2\) 复制进去, 然后尝试把 \(B_1\) 的元素往 \(S\) 里面插.

如果 \(B_1\) 的元素 \(x\) 插入的时候没有被异或为 \(0\), 说明它不可以被 \(S\) 中的元素表示. 于是将其插入 \(S\).

如果 \(x\) 可以被 \(S\) 异或为 \(0\), 且可以仅被 \(B_2\) 的元素异或为 \(1\), 说明 \(x\) 属于 \(B\), 将 \(x\) 直接放入 \(B\) 中即可.

如果 \(x\) 需要被 \(B_1\) 已经插入 \(S\) 中的元素和 \(B_2\) 中的元素共同异或为 \(0\), 那么我们用 \(B_1\) 已经插入 \(S\) 的元素异或 \(x\) 不会对线性基的性质产生任何影响, 所以可以转化为上一种情况, 把调整后的 \(x\) 插入 \(B\) 即可.

最后求出的 \(B\) 即为 \(A_1 \cap A_2\) 的基.

在线删除

我们前面求的是 \(\{a\}\) 集合生成的线性空间 \(A\) 的基 \(B\), 那么如果需要支持删除数字, 如何维护 \(B\) 呢?

我们设 \(B_i\) 为 \(B\) 中最高位为 \(i\) 的元素.

对于每个插入时没有异或为 \(0\) 的数字 \(a_i\), 我们认为它为线性空间增加了一维, 异或后插入到了位置 \(B_j\). 这时我们给这一维赋一个空闲的维度编号 \(R\). 这个编号不能是最高位位置 \(j\), 原因在最后解释.

所以我们单独开一个名为 \(Exi\) 的 bitset, \(Exi_i = 0\) 表示这个维度编号空闲. 每次开启新维度时, \(R\) 就是扫描这个数组得到的.

记一个数组 \(Bel_i\) 表示 \(a_i\) 生成的维度的编号, 如果 \(a_i\) 没有生成任何维度则 \(Bel_i = \infin\).

如果把每个 \(Bel_i \neq \infin\) 的 \(a_i\) 作为 \(|B|\) 个维度的单位向量, 那么对于线性空间内每个数, 都可以由这些单位向量中的一部分异或而来的.

每个 \(a_i\) 维护一个集合 \(Set_i\), 表示 \(a_i\) 是由哪些维度的单位向量异或而来的.

每个 \(B_i\) 维护一个集合 \(BSet_i\), 表示 \(B_i\) 是由哪些维度的单位向量异或而来的.

还要记录一个 bitset \(Del\), \(Del_i = 1\) 表示 \(a_i\) 已经被删除了.

这时假设要删除的是 \(a_i\), 那么可以按 \(Bel_i\) 分为两类.

\(Bel_i = \infin\)

这就说明 \(a_i\) 的插入并没有给 \(A\) 带来新的元素, 那么 \(a\) 删除之后 \(A\) 也不会变化, 所以它的基 \(B\) 也不会变化, 我们什么都不用做.

\(Bel_i \neq \infin\)

我们这时候要尝试找出一个未被删除且 \(Bel_d = \infin\) 的数 \(a_d\), 满足 \(Bel_i \in Set_d\).

\(d\) 存在

如果我们设 \(F(Set)\) 表示维度集合 \(Set\) 内所有维度的单位向量的异或和. 则有

\[\begin{aligned} a_d &= F(Set_d)\\ a_d &= F(Set_d \backslash Bel_i) \oplus a_i\\ a_d \oplus a_i &= F(Set_d \backslash Bel_i)\\ a_i &= F(Set_d \backslash Bel_i) \oplus a_d\\ \end{aligned} \]

那么对于 \(A\) 中的任意元素 \(x\), 一定有集合 \(Set\) 使得 \(x = F(Set)\). 如果 \(Bel_i \notin Set\), 则删除 \(a_i\) 不会对生成 \(x\) 产生影响. 如果 \(Bel_i \in Set\) 那么就有:

\[\begin{aligned} x &= F(Set)\\ x &= F(Set \backslash Bel_i) \oplus a_i\\ x &= F(Set \backslash Bel_i) \oplus F(Set_d \backslash Bel_i) \oplus a_d\\ \end{aligned} \]

因为 \(Set \backslash Bel_i\) 和 \(Set_d \backslash Bel_i\) 都不含 \(Bel_i\), 所以它们都可以在 \(a_i\) 不存在的时候结合 \(a_d\) 凑出 \(x\). 也就是说删除 \(a\) 也不会使得 \(A\) 发生任何变化, 所有需要 \(a\) 参与生成的元素都可以由 \(b_1\) 生成, 所以我们不对 \(B\) 进行任何修改.

但是我们需要把 \(Bel_i\) 维度的单位向量改成 \(a_d\), 这样会使 \(Set\) 和 \(BSet\) 都发生变化.

因为对于包含 \(Bel_i\) 的集合 \(Set\), 在这个维度单位向量变化后, \(F(Set)\) 会变成 \(F(Set) \oplus F(Set_d \backslash Bel_i)\). 为了使所有这种 \(Set\) 的 \(F(Set)\) 仍然等于原来的 \(F(Set)\).

我们如果想对它进行修正, 就要使 \(F(Set) \oplus F(Set_d \backslash Bel_i)\) 再异或一个 \(F(Set_d \backslash Bel_i)\).

体现在 \(Set\) 上就是使得 \(Set\) 变成 \(Set \oplus (Set_d \backslash Bel_i)\). 这个修正操作对每个包含 \(Bel_i\) 的 \(Set_j\) 和 \(BSet_j\) 都要进行.

由于我们已经把 \(a_d\) 选为维度 \(Bel_i\) 的单位向量, 所以将 \(Bel_d\) 赋值为 \(Bel_i\).

\(d\) 不存在

说明删掉 \(a_i\) 会让维度 \(Bel_i\) 消失, 我们需要在 \(B\) 中删掉一个元素, 并且把 \(Exi_{Bel_i}\) 变成 \(0\).

如果 \(A\) 中任意元素 \(x\) 都可以表示为 \(x = F(Set)\).

\(A\) 减少一维意味着减少一半的元素, 也就是删除所有 \(Bel_i \in Set\) 的 \(x\).

因为所有 \(x\) 都是 \(B\) 的元素异或出来的, 如果所有 \(BSet_j\) 都满足 \(Bel_i \notin BSet_j\), 那么自然就无法生成 \(Bel_i \in Set\) 的 \(x\) 了.

解法1

先考虑把所有 \(Bel_i \in BSet_j\) 的所有 \(B_j\) 都异或 \(a_i\). 这时可以在 \(BSet\) 中清除所有 \(Bel_i\), 但是这时 \(BSet\) 的元素不是线性无关的. 所以需要进行一轮高斯消元.

解法2

重新审视线性基的性质, 我们发现可以选一个 \(k\), 使其满足 \(Bel_i \in BSet_k\), 然后把所有满足 \(Bel_i \in BSet_j\) 的 \(B_j\) 都异或 \(B_k\), 这样也可以消除所有 \(BSet\) 中的 \(Bel_i\).

如果我们选择 \(k\) 的时候让 \(B_k\) 尽可能小, 那么最后异或结束后除了 \(B_k\) 变成 \(0\) 以外, 其它的元素因为最高位比 \(B_k\) 高, 所以最高位没有发生变化, 所以在 \(B\) 中的位置也不会变化. 为了方便, 我们这样选择 \(k\).

注意在异或过程中同步维护 \(BSet\).

编号单独维护的原因

如果用 \(B_i\) 最高位作为维度编号, 在这组数据中会出问题:

Insert 3
Insert 2
Delete 3
Insert 1

\(3\) 生成了维度 \(1\), \(B\) 插入了新元素 \(B_1 = 3\), 同时 \(BSet_1 = \{1\}\).

\(2\) 生成了维度 \(0\), \(B\) 插入了新元素 \(B_0 = 1\), 同时 \(BSet_0 = \{0, 1\}\).

如果删除 \(3\), 会删除维度 \(1\), 这时所有 \(1 \in BSet_i\) 的集合中, \(B_i\) 最小的是 \(B_0 = 1\), 所以使得 \(B_0\), \(B_1\) 都异或 \(B_0\), 同时 \(BSet_0\), \(BSet_1\) 异或 \(BSet_0\).

得到了 \(B_0 = 0\), \(BSet_0 = \empty\), \(B_1 = 2\), \(BSet = \{0\}\).

虽然插入 \(a_i\) 之前线性基不存在最高位为 \(j\) 的元素, 但是在此之前最高位为 \(j\) 的元素可能插入并删除了, 在这个元素存在的时候,

如果这个时候插入 \(1\), 会生成新的维度, \(B\) 插入新元素 \(B_0 = 1\), 最高位为 \(0\), 但是维度 \(0\) 仍然存在, 所以这样编号会和已经存在的维度 \(0\) 冲突.

复杂度分析

我们在插入 \(a_i\) 的时候需要维护大小为 \(\log V\) 的集合 \(Set_i\), 大小为 \(\log V\) 的向量 \(a_i\), 进行 \(\log V\) 次异或. 如果最后出现了新的维度, 需要遍历大小为 \(\log V\) 的 bitset \(Exi\), 复杂度 \(O(\frac{\log^2 V}w)\).

删除 \(a_i\) 时, 如果 \(Bel_i = \infin\), 则 \(O(1)\).

然后我要遍历 \(|\{a\}|\) 个集合来寻找 \(d\), \(O(|\{a\}|)\).

如果存在 \(d\), 那么我需要将 \(O(|\{a\}| + \log V)\) 个大小为 \(\log V\) 的集合异或一个同样大小的集合, \(O(\frac{(|\{a\}| + \log V)\log V}w)\).

如果没有 \(d\), 那么我需要遍历 \(O(\log V)\) 个大小为 \(O(\log V)\) 的集合并且选出集合进行异或, 复杂度 \(O(\frac {\log^2 V}w)\)

如果操作数是 \(n\), 则总复杂度是 \(O(n(\frac{\log^2V + |\{a\}|\log V}w + |\{a\}|))\). 如果认为 \(O(|\{a\}|) = O(n)\), 则复杂度为 \(O(n(\frac{\log^2V + n\log V}w + n)) = O(n^2 + \frac{n^2\log V}w + \frac{n\log^2V}w)\)

代码实现

模板题, 可惜时间复杂度过不了.

map<unsigned, vector<unsigned> > a;
bitset<500005> Del;
bitset<32> Exi;
unsigned Set[500005], Bel[500005], BSet[32], Bin[32], B[32], m, n;
unsigned C, D, Rk, Line;
unsigned Cnt(0), Ans(0);
int A;
void Ins(int i, unsigned Val) {
  unsigned Highest(0x3f3f3f3f);
  for (unsigned j(30); ~j; --j) if (Val & Bin[j]) {
    if (B[j]) Val ^= B[j], Set[i] ^= BSet[j];
    else { B[j] = Val, Highest = j; break; }
  }
  if (Highest ^ 0x3f3f3f3f) for (unsigned j(0); j <= 30; ++j)
    if (!Exi[j]) { BSet[Highest] = (Set[i] | Bin[j]), Exi[Bel[i] = j] = 1; break; }
}
void Delt(int i) {
  Del[i] = 1;
  if (Bel[i] == 0x3f3f3f3f) return;
  unsigned z(0x3f3f3f3f), Line(Bel[i]);
  for (int x(0); x < Cnt; x++) if ((!Del[x]) && (Bel[x] == 0x3f3f3f3f) && (Set[x] & Bin[Line])) { z = x; break; }
  if (z ^ 0x3f3f3f3f) {// Replace i by z
    Bel[z] = Line;
    unsigned t(Set[z] ^ Bin[Line]);
    for (unsigned x(0); x < Cnt; ++x) if (Set[x] & Bin[Line]) Set[x] ^= t;
    for (unsigned x(0); x <= 30; ++x) if (BSet[x] & Bin[Line]) BSet[x] ^= t;
    return;
  }
  unsigned XPos(0x3f3f3f3f), Xor, XSet;
  for (unsigned x(0); x <= 30; ++x) if (BSet[x] & Bin[Line]) {
    if (XPos == 0x3f3f3f3f) XPos = x, Xor = B[x], XSet = BSet[x];
    B[x] ^= Xor, BSet[x] ^= XSet;
  }
  Exi[Line] = 0;
}
signed main() {
  memset(Bel, 0x3f, sizeof(Bel));
  Bin[0] = 1;
  for (unsigned i(1); i <= 30; ++i) Bin[i] = (Bin[i - 1] << 1);
  n = RD();
  for (unsigned i(1); i <= n; ++i) {
    if (!(i % 10000)) fprintf(stderr, "Now %u\n", i);
    A = RDsg(), Ans = 0;
    if (A < 0) D = -A, Delt(a[D].back()), a[D].pop_back();
    else D = A, a[D].push_back(Cnt), Ins(Cnt++, D);
    for (unsigned j(30); ~j; --j) if (B[j] && (!(Ans & Bin[j]))) Ans ^= B[j];
    printf("%u\n", Ans);
  }
  return Wild_Donkey;
}

离线删除

线段树

可以对时间构造线段树, 每个插入的元素看成一个区间修改, 区间就是它存在的时间区间, 区间修改会遇到 \(O(\log n)\) 个节点, 给这些节点的 vector 中压入这个元素即可.

插入结束后对线段树每个节点求出自己 vector 中所有元素的线性基.

每次查询的时候, 在线段树上单点查询的时候合并 \(O(\log n)\) 个线性基, 相当于 \(O(\log n \log V)\) 次插入, 复杂度是 \(O(m \log n \log^2 V)\). 如果按时间顺序回答询问, 每次用回滚的方式代替从头开始合并, 则可以均摊所有询问最多会合并 \(O(n)\) 次, 需要 \(O(n \log V)\) 次插入, 复杂度 \(O(n \log^2 V)\).

我们同样可以在线段树构造完之后, DFS 使得每个节点的线性基变成父亲和自己线性基合并的结果. 这样每个时间的答案便可以在 \(O(n \log^2 n)\) 的时间内处理出来.

下面这份代码可以通过前面提到的模板题.

map<unsigned, vector<unsigned> > a;
unsigned Bin[32], B[31], n, D, CL, CR;
unsigned Cnt(0), Ans(0);
int A;
inline void Ins(unsigned x) {
  for (unsigned i(30); (~i) && x; --i) if (x >> i) {
    if (B[i]) x ^= B[i];
    else { B[i] = x; return; }
  }
}
struct Node {
  vector <unsigned> Val;
  Node* LS, * RS;
  inline void Chg(unsigned L, unsigned R) {
    if ((CL <= L) && (R <= CR)) { Val.push_back(D); return; }
    unsigned Mid((L + R) >> 1);
    if (CL <= Mid) LS->Chg(L, Mid);
    if (CR > Mid) RS->Chg(Mid + 1, R);
  }
  inline void DFS() {
    unsigned Bf[31];
    memcpy(Bf, B, sizeof(B));
    for (auto i : Val) Ins(i);
    if (!LS) {
      Ans = 0;
      for (unsigned i(30); ~i; --i) if (B[i] && (!(Ans & Bin[i]))) Ans ^= B[i];
      printf("%u\n", Ans);
    }
    else LS->DFS(), RS->DFS();
    memcpy(B, Bf, sizeof(B));
    return;
  }
}N[1000005], * CntN(N);
inline void Build(Node* x, unsigned L, unsigned R) {
  if (L == R) return;
  unsigned Mid((L + R) >> 1);
  Build(x->LS = ++CntN, L, Mid);
  Build(x->RS = ++CntN, Mid + 1, R);
}
signed main() {
  Bin[0] = 1;
  for (unsigned i(1); i <= 30; ++i) Bin[i] = (Bin[i - 1] << 1);
  n = RD(), Build(N, 1, n);
  for (unsigned i(1); i <= n; ++i) {
    A = RDsg(), Ans = 0;
    if (A < 0) D = -A, CL = a[D].back(), CR = i - 1, N->Chg(1, n), a[D].pop_back();
    else D = A, a[D].push_back(i);
  }
  for (auto i : a) { D = i.first;  for (auto j : i.second) CL = j, CR = n, N->Chg(1, n); }
  fprintf(stderr, "Done\n");
  N->DFS();
  return Wild_Donkey;
}

无线段树

我们发现在线删除时, 最耗费时间的是维护 \(Set\), 如果能想办法避免维护 \(Set\), 时间复杂度就会得到非常大的优化.

分析 \(Set\) 的作用, 发现它被用来寻找 \(d\), 也就是 \(Bel = \infin\) 的可以代替 \(a_i\) 的元素. 如果想办法消除 \(d\) 存在情况就可以省略这个判断了.

另需维护数组 \(b\) 使得最高位为第 \(i\) 位的 \(b_i\)

具体措施是处理出每个元素的删除时间, 然后在插入 \(a_i\) 时, 如果 \(a_i\) 生成新的维度, 则按原来的写法维护.

如果不能生成新的维度, 我们求出 \(Set_i\) (注意这里不维护所有数字的 \(Set\), 仅求出 \(a_i\) 对应的 \(Set_i\) 作为临时变量使用), 找出所有维度 \(j \in Set_i\) 中单位向量删除时间最早的单位向量 \(a_k\). 如果 \(a_k\) 在 \(a_i\) 之后删除, 则什么也不做, 否则直接用 \(a_i\) 作为维度 \(Bel_k\) 的单位向量, 进行替换操作.

复杂度: 在原来的基础上去掉维护和查询 \(Set\) 的复杂度, 复杂度为 \(O(\frac{n\log^2V}w)\).

struct Num {
  unsigned In, Out, Val;
}List[500005];
map<unsigned, vector<unsigned> > a;
bitset<32> Exi;
unsigned Move[500005], Bel[500005], BSet[32], Bin[32], B[32], b[32], m, n;
unsigned C(0), D, Rk;
unsigned Cnt(0), Ans(0);
int A;
void Delt(int x) {
  if (Bel[x] == 0x3f3f3f3f) return;
  unsigned Line(Bel[x]), XPos(0x3f3f3f3f), Xor, XSet;
  for (unsigned i(0); i <= 30; ++i) if (BSet[i] & Bin[Line]) {
    if (XPos == 0x3f3f3f3f) XPos = i, Xor = B[i], XSet = BSet[i];
    B[i] ^= Xor, BSet[i] ^= XSet;
  }
  for (unsigned i(0); i <= 30; ++i) if (b[i] == x) { b[i] = b[XPos]; break; }
  b[XPos] = Exi[Line] = 0, Bel[x] = 0x3f3f3f3f;
}
signed main() {
  memset(Bel, 0x3f, sizeof(Bel));
  Bin[0] = 1;
  for (unsigned i(1); i <= 30; ++i) Bin[i] = (Bin[i - 1] << 1);
  n = RD();
  for (unsigned i(1); i <= n; ++i) {
    A = RDsg(), Ans = 0;
    Num* Cur;
    if (A < 0) Cur = List + a[D = -A].back(), Cur->Out = i - 1, Move[i] = Cur - List, a[D].pop_back();
    else D = A, a[D].push_back(++Cnt), List[Move[i] = Cnt] = Num{ i, 0, D };
  }
  for (auto i : a) { D = i.first;  for (auto j : i.second) List[j].Out = n; }
  for (unsigned i(1); i <= n; ++i) {
    if (!(i % 50000)) fprintf(stderr, "Now %u\n", i);
    unsigned x(Move[i]);
    Num* Cur(List + x);
    Ans = 0, D = Cur->Val;
    if ((Cur->In) ^ i) Delt(x);
    else {
      unsigned Highest(0x3f3f3f3f), TmpS(0), Line(0), TmpD(D);
      for (unsigned j(30); ~j; --j) if (D & Bin[j]) {
        if (B[j]) D ^= B[j], TmpS ^= BSet[j];
        else { b[j] = x, B[j] = D, Highest = j; break; }
      }
      if (Highest ^ 0x3f3f3f3f) {
        for (unsigned j(0); j <= 30; ++j) if (!Exi[j]) { Exi[Line = Bel[x] = j] = 1; break; }
        BSet[Highest] = (TmpS | Bin[Line]);
      }
      else {
        unsigned Last(0x3f3f3f3f);
        for (unsigned j(0); j <= 30; ++j) if (b[j] && (TmpS & Bin[Bel[b[j]]]) && (List[b[j]].Out < Last))
          Last = List[b[j]].Out, Line = Bel[b[j]], Highest = j;
        if (Last < Cur->Out) {
          Bel[b[Highest]] = 0x3f3f3f3f, Bel[b[Highest] = x] = Line, TmpS ^= Bin[Line];
          for (unsigned j(0); j <= 30; ++j) if (BSet[j] & Bin[Line]) BSet[j] ^= TmpS;
        }
      }
    }
    for (unsigned j(30); ~j; --j) if (B[j] && (!(Ans & Bin[j]))) Ans ^= B[j];
    printf("%u\n", Ans);
  }
  return Wild_Donkey;
}

优化

是否可以通过插入的特判避免 \(BSet\) 的维护, 使得程序更简洁.

考虑 \(BSet\) 的作用, 在删除一个维度 \(i\) 的时候, 需要把所有被维度 \(i\) 的单位向量 \(a_j\) 生成的 \(B_k\) 都异或上最小的 \(B_k\). \(BSet\) 的作用就是找出所有这些 \(B_k\). 如果能使每次找出的 \(B_k\) 都只有 \(B_i\) 一个, 只要让它自己变成 \(0\) 即可, 那么我们便不需要维护 \(BSet\) 了.

避免了 \(B\) 的互相异或, 无需维护任何维度集合, 所以维度编号就不用记录了. 我们可以把 \(i\) 作为 \(B_i\) 插入时新建的维度的编号, 也就是最高位位置.

为了实现每次删除 \(a_{b_i}\) 时, 只有 \(B_i\) 是需要单位向量 \(a_{b_i}\) 参与才能生成. 需要保证线性基中每个 \(B_i\) 只需要不比 \(i\) 删除得早的维度的单位向量参与生成.

由于避免了 \(B\) 的相互异或, \(B_i\) 的元素都是从高位一路异或过来才插入的, 所以只要一个时刻内, 满足任意 \(B_i\) 只需要 \(a_{b_j}\ (j \geq i)\) 参与即可生成, 那么任何后来插入的 \(B_i\) 都不会需要 \(j < i\) 的 \(a_{b_i}\) 参与即可生成. 显然 \(B\) 为空的时候满足这个条件, 所以任何时刻 \(B\) 都能满足这个条件.

接下来我们只需要满足维度 \(i\) 删除时间比任意 \(j < i\) 都晚, 这样因为前面的性质, 就可以满足 \(B_i\) 可以被删除时间不比 \(i\) 早的维度 \(j\) 的单位向量即可生成.

为了使得 \(i\) 删除时间比 \(j < i\) 的 \(j\) 晚, 我们需要在插入时进行一些操作.

如果这时向线性基内插入 \(a_i\), 过程中记录 \(A\) 表示 \(a_i\) 异或一些 \(k > j\) 的 \(a_{b_k}\) 得到的结果. 遇到 \(B_j\) 和 \(A\) 最高位相同, 按 \(a_i\) 和 \(a_{b_j}\) 的删除时间分类讨论:

• \(a_i\) 更早删除
  那么直接用 \(B_j\) 异或 \(A\), 然后用新的 \(A\) 继续这个过程讨论后面的元素.

• \(a_{b_j}\) 更早删除
  这时候 \(A\) 可以只用 \(a_{b_k}\ (k < j)\) 和 \(a_i\) 生成, 所以有资格作为 \(B_j\), 我们使 \(a_i\) 作为维度 \(j\) 的单位向量, 而 \(a_{b_j}\) 则是作为 \(B\) 中别的元素的单位向量.
  实现上是交换 \(B_j\) 和 \(A\) 的数值, 然后交换 \(b_j\) 和 \(i\) 的数值, 就可以用新的 \(A\) 和 \(i\) 继续这个过程的讨论. 我们只是把 \(B_j\) 暂时拿到了外面, 并不是把它删除, 因为原来的维度 \(j\) 仍然存在, 只是编号不知道变成什么了, 并且 \(b_j\) 也参与生成其它 \(k < j\) 的 \(B_k\).

这个过程直到 \(A\) 或 \(B_j\) 其中任何一个变成 \(0\) 结束. 如果 \(B_j\) 先为 \(0\), 说明 \(a_i\) 产生了新的维度, 赋值 \(b_j = i\), \(B_j = A\). 如果 \(A\) 先变成 \(0\), 则没有新维度产生, 直接跳出.

过程复杂度不变, 但是得到了简化.

map<unsigned, unsigned> a;
unsigned Val[500005], Out[500005], Bin[32], B[32], b[32], n;
unsigned C(0), D, Rk;
unsigned Cnt(0), Ans(0);
int A;
signed main() {
  n = RD(), Bin[0] = 1; for (unsigned i(1); i <= 30; ++i) Bin[i] = (Bin[i - 1] << 1);
  memset(Out, 0x3f, (n + 1) << 2);
  for (unsigned i(1); i <= n; ++i) {
    A = RDsg(), Ans = 0;
    if (A < 0)  Out[Val[i] = Out[i] = a[D = -A]] = i - 1;
    else a[Val[i] = D = A] = i;
  }
  for (unsigned i(1); i <= n; ++i) if (Out[i] == 0x3f3f3f3f) Out[i] = n;
  for (unsigned i(1); i <= n; ++i) {
    if (!(i % 50000)) fprintf(stderr, "Now %u\n", i);
    Ans = 0, D = Val[i];
    if (i > Out[i]) { for (unsigned j(0); j <= 30; ++j) if (b[j] == D) { B[j] = b[j] = 0; break; } }
    else {
      unsigned Cur(i);
      for (unsigned j(30); (~j) && D; --j) if (D & Bin[j]) {
        if (B[j]) { if (Out[b[j]] < Out[Cur]) swap(D, B[j]), swap(Cur, b[j]); D ^= B[j]; }
        else { b[j] = Cur, B[j] = D; break; }
      }
    }
    for (unsigned j(30); ~j; --j) if (B[j] && (!(Ans & Bin[j]))) Ans ^= B[j];
    printf("%u\n", Ans);
  }
  return Wild_Donkey;
}

例题

ABC223H

给一个序列, 每次询问一个区间 \([l, r]\) 的数字通过异或是否可以得到一个给出的数字 \(X\).

很容易想到用线段树, 每个节点存这个区间的线性基. 每次查询时把 \(\log n\) 个线性基合并起来, 直接查询 \(X\) 是否存在于这个线性基的线性空间里. 单次查询复杂度 \(O(\log n \log^2 V)\), 不能通过.

我们如果查询的是后缀而非区间, 一个贪心的思想是只要能用较短的后缀生成的数字, 那么比这个长的后缀就同样可以生成. 也就是说我们尝试使用尽可能靠后的元素生成 \(X\). 如果存在两个元素, 插入当前线性基后得到的线性空间相同, 那么靠后面的元素相对于前面的元素更有价值.

思考优化过的线性基离线删除的算法, 相当于是让每一对 \(i < j\) 满足 \(a_{b_i}\) 比 \(a_{b_j}\) 先删除. 用尽可能删除晚的元素代替同位置的删除早的元素, 贪心地维护这个线性基.

推广到区间修改上, 就是一边从左往右插入, 一边在这个长度为 \(i\) 前缀生成的线性空间的线性基上回答 \(r = i\) 的询问. 如果生成过程中出现了需要使用 \(B_j\) 而 \(b_j < l\) 的情况, 则回答是否定的. 如果无法生成 \(X\), 则答案仍是否定的. 其余情况答案是肯定的.

struct Query {
  unsigned long long Val;
  unsigned L, R, Num;
  inline const char operator < (const Query& x) const { return R < x.R; }
}Q[200005];
unsigned long long a[400005], B[60];
unsigned Pos[60], C, D, m, n;
unsigned Cnt(0), Tmp(0);
bitset<200005> Ans;
signed main() {
  n = RD(), m = RD();
  for (unsigned i(1); i <= n; ++i) a[i] = RDll();
  for (unsigned i(1); i <= m; ++i) Q[i].L = RD(), Q[i].R = RD(), Q[i].Val = RDll(), Q[i].Num = i;
  sort(Q + 1, Q + m + 1);
  for (unsigned i(1), j(1); j <= m; ++j) {
    while (i <= Q[j].R) {
      unsigned long long A(a[i]);
      unsigned P(i++);
      for (unsigned k(59); (~k) && A; --k) if (A >> k) {
        if (!B[k]) { Pos[k] = P, B[k] = A;break; }
        if (P > Pos[k]) swap(P, Pos[k]), swap(A, B[k]);
        A ^= B[k];
      }
    }
    unsigned long long A(Q[j].Val);
    unsigned P(Q[j].L);
    for (unsigned k(59); ~k; --k) if (A >> k) {
      if (P > Pos[k]) break;
      A ^= B[k]; if (!A) { Ans[Q[j].Num] = 1; break; }
    }
  }
  for (unsigned i(1); i <= m; ++i) printf(Ans[i] ? "Yes\n" : "No\n");
  return Wild_Donkey;
}