用户甲如果让我挑一个在算法竞赛里“看起来很高端，其实练熟了就很无脑”的串味知识，一定跑不掉异或线性基。很多人第一次见到“线性基”三个字时会被唬住，以为是什么高深的线性代数推导，实际上它解决的问题非常朴素：给你一堆整数，让你研究“任选一些数异或起来，能得到哪些结果”，而线性基就是维护这个异或集合的一个极简工具。这篇文章主要讲清楚线性基的原理、C++ 实现、高频场景和几个我在实际做题中踩得比较深的坑，全文不聊太多数学证明，只把“为什么能这么写”讲明白，适合刚接触异或线性基的读者，也适合复习冲刺的人。
1. 线性基是啥，先把概念说清
1.1 从异或运算的基本性质说起
异或的本质是二进制下的不进位加法，这也是它经常出现在算法题目里的根本原因。比如布尔代数里，异或的表达式可以写成 A⊕B = (A∧¬B)∨(¬A∧B)，字面意思就是“两个位不一样的时候结果是 1”。在 C++ 里，异或对应运算符 ^，基础时间复杂度是 O(1)。很多初学者会用异或交换两个变量、找唯一出现奇数次的元素，这些技巧之所以成立，都是因为异或满足交换律、结合律，还有最重要的两条：任何一个数和 0 异或还是它自己；任何一个数和自己异或结果是 0。
我发现很多同学在理解线性基时卡住，其实是卡在一个点上：解空间不是“通常的加法”，而是异或。如果你把数组里的每个元素看成二进制向量，那么“选几个数异或起来”其实就是“选几个向量，在模 2 下做线性组合”。所谓线性基，可以粗糙理解成“同一组数能异或出来的所有结果的极小表示集合”。
1.2 线性基与“张出的异或空间”
严格一点说，给定 n 个数 a₁, a₂, ..., aₙ，所有子集的异或和组成的集合 S，一定可以用一个最多不超过 60 个数字的线性基 B 来表示。为什么上限是 60？因为如果数的大小在 1e18 量级，二进制位不到 60 位。关键性质是：原数组能异或出来的任何一个值，线性基也一定能异或出来；线性基能异或出来的值，原数组也一定能异或出来。两边张出的集合完全相等。
举一个很简单的例子，原数组是 [4, 6, 7]。把二进制写出来：4 = 100，6 = 110，7 = 111。这三个数其实可以互相表出，6 = 4 ⊕ 7，或者 7 = 4 ⊕ 6。那问题就来了：如果题目换成一个 1e5 大小的数组，冗余元素会非常多，直接枚举子集复杂度是 O(2^n)，根本没法做。但如果用线性基压缩，最多只保留 60 个“骨干”。对于一个数学上听起来很复杂的结构，落到算法里，目的就是降规模。
1.3 为什么线性基能压缩信息
我自己的理解方式是这样的：线性基其实是一组“互相独立的异或组”。所谓独立，就是任何一个基础向量都不能由其他基础向量异或得到。这个和线性代数里的“线性无关”概念一样，只不过这里系数只有 0 和 1。
当你插入一个新数 x 时，如果 x 已经可以由现有的基向量异或出来，那 x 就是冗余的；如果 x 带来了新的“维度”，就必须被放进线性基里。很多时候我们并不关心原数组具体有哪些数，只关心它们能生成哪些异或值，所以可以把原数组压缩成一堆尽量极简的向量。有人会把选数异或问题类比成“拼凑套餐”：原数组给了几十种商品，但真正决定你能拼出哪些价格的，其实只有几种关键商品，其他都可以被这几种商品通过“叠加”代替。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 算法实现与两种存储形式
2.1 插入操作：逐位贪心
线性基的核心函数就是插入。一般的做法是维护一个数组 base[i]，表示当前第 i 个二进制位对应的“基向量”，这里 i 从高到低或者低到高都可行，但最常见的是从高位开始考虑。
插入流程是这样的：拿到一个新数 x，从最高位开始往下找。假设当前检查到第 i 位，如果 x 的第 i 位是 0，直接跳过；如果第 i 位是 1，再看 base[i] 是否为空。如果 base[i] 为空，就令 base[i] = x，然后结束；如果 base[i] 非空，就让 x = x ^ base[i]，继续往下检查。为什么这里的核心操作是异或而不是别的东西？因为在二进制不进位加法的意义下，异或能把 x 中已经被现有 base[i] 表示的“部分”消掉。
当 x 经过程序最终变成 0 时，就意味着 x 已经被现有线性基完全表示，它是一个冗余元素；如果某个时候成功放入 base[i]，说明这个数给线性基贡献了一个新的维度。
这里我打个比方：base[i] 就好像每一层的“引路人”。你要把你的数送到某个新的高位，路上如果遇到已经存在的大佬，就跟它异或一下，被它消掉一部分；一直消到有一位没人占据，你就住进去。如果一路消到底都没地方住，那说明你并不是真的新人。
2.2 普通线性基构建代码（C++）
下面这段是我常用的模板，实现时把 base 数组开成 long long 类型，注意位移的循环方向。
cpp复制using ll = long long;
const int MAXB = 60;
struct LinearBasis {
ll base[MAXB + 1];
LinearBasis() {
memset(base, 0, sizeof(base));
}
// 尝试向线性基中插入 x
bool insert(ll x) {
for (int i = MAXB; i >= 0; --i) {
if (!(x >> i & 1)) continue;
if (!base[i]) {
base[i] = x;
return true;
}
x ^= base[i];
}
return false;
}
};
这个 insert 看起来简单，但有两处容易写错。第一是循环边界，如果最大值到 1e18，闭区间从 60 到 0 足够了，写成 63 也可以但纯属浪费；第二是判断第 i 位是否为 1，别把 if (!(x >> i & 1)) 写成 if ((x >> i & 1) == 0) 之外的奇怪形式，虽然也对，但阅读性不好。
普通线性基的特点是，同一个高位只可能有一个 base 非空，但这些 base 的低位未必干净。举个例子，base[3] 可能是 1011，它把自己的低位也带上了一些信息。这样存储、插入还好办，但求第 k 小会出问题，所以后面还需要第二种形式。
2.3 类上三角 base 与消成干净向量
所谓把线性基变成“干净形式”，也叫重构。目标是让每个 base[i] 满足这样的性质：除了第 i 位以外，base[i] 在其他已经存在于线性基的更高位上都是 0。直观理解，就是让每个基向量只“管住”自己最高位的那一位，其他位尽量不影响别人。
重构方法是从高往低处理：设当前 i 是线性基里的一个非空位，对 j > i 的所有非空 base[j]，如果 base[j] 的第 i 位是 1，就令 base[j] ^= base[i]。很多讲解喜欢改成“从低位到高位”的重构，实际上代码顺序取决于你要实现什么目标。我个人习惯求第 k 小前做一次从高到低消元。
还有一种说法叫上三角矩阵化形式，也就是所有 base[i] 的最高位严格不重复，且任意两个 base 异或后最高位不会落到更低的那一个上。这种形式对于查询是否可表示、求最大值、求第 k 小非常友好。
cpp复制void rebuild() {
for (int i = MAXB; i >= 0; --i) {
if (!base[i]) continue;
for (int j = i - 1; j >= 0; --j) {
if (!base[j]) continue;
if (base[i] >> j & 1) {
base[i] ^= base[j];
}
}
}
}
很多新手会问，为什么这个循环里 j 是从低到高或者从高到低都行，只要保证 base[i] 的更低位的“杂质”被消掉就行。你可以画一个 3 位的例子试一下：先用普通插入放入 101 和 011，然后重建，处理高位 2 时会把低位 1 里的杂质消干净。最终得到的 base[2] 和 base[1] 之间不会再有相互表示。
3. 经典应用场景拆解
3.1 最大异或和：贪心从高位往下选
最大异或和是线性基最出名的应用。题意通常是给一个数组，选任意个子集，使异或和最大。没有线性基之前，所有人第一反应是排序取最大值或者高位置越多越好，但贪心直接做会有问题，比如数组 [8, 7]，按位贪心先选最高位的 8，得到 8，但最优其实是 8 ^ 7 = 15。线性基为什么能解决？因为在重构后的线性基里，任意一个向量不会干扰比它更高位的决策。
求解时，令 ans = 0，从高位 downto 0 扫描，如果当前位有 base 且 ans ^ base[i] > ans，就执行 ans ^= base[i]。为什么这个贪心是对的？因为二进制数是高位优先的，从最高位开始，能变成 1 就要尽量变 1；线性基的性质保证了把 base[i] 异或上去不会破坏已经确定的高位结果。
cpp复制ll queryMax() {
ll ans = 0;
for (int i = MAXB; i >= 0; --i) {
if ((ans ^ base[i]) > ans) {
ans ^= base[i];
}
}
return ans;
}
在实际做的时候，一种更省代码的写法是：for (int i = MAXB; i >= 0; i--) if ((ans ^ base[i]) > ans) ans ^= base[i]; 在普通未重建的线性基上也适用，因为贪心挑选时高位的确定性能够覆盖低位可能导致的交叉影响。
我特别注意过一个问题：最大值一定包含最高位的那个 base 吗？不一定。比如线性基里只有 base[2] = 101 这一个向量，那最大答案就是 101。如果还有 base[1] = 1010，但不是每个高位都会被选，因为可能异或上去会降低高位原本就为 1 的值。所以代码里只做 if 判断就好，不需要硬选。
3.2 求第 k 小异或和：先重建再拆位
第 k 小问题往往是初学者最怕的。题目问你：所有可选子集的异或和中，第 k 小是几？
这里有一个非常透明的坑：普通线性基里可能携带互相重复的组合，直接按位看 k 的二进制会出错。必须先把线性基重建，然后一步步提取。
重建完成后，假设有 cnt 个非空的基向量，那么一共能表示出 2^cnt 个不同的异或值（不含 0 时数量是这样；如果原数组能异或出 0，还要额外算上 0）。求第 k 小的时候，很多人的直觉是：把 k 拆成二进制，然后如果 k & (1 << j)，就用第 j 小那个基底。
网上的代码风格差异挺大，我提供一个我能反复验证的版本。关键是把每个非空 base[i] 的位全部压到低位，形成一个“有序向量列表”，再按 k 的二进制位拼接。
cpp复制ll queryKth(ll k) {
rebuild();
vector<ll> vec;
for (int i = 0; i <= MAXB; ++i) {
if (base[i]) vec.push_back(base[i]);
}
int cnt = (int)vec.size();
if (k >= (1LL << cnt)) return -1; // 表示不存在第 k 小
ll ans = 0;
for (int i = 0; i < cnt; ++i) {
if (k >> i & 1) {
ans ^= vec[i];
}
}
return ans;
}
这段代码有两个前提。第一个前提是“能否异或出 0”需要单独处理：如果 n 个数传入时存在冗余元素（insert 返回 false 的数），就说明 0 存在于可表示集合中，第 1 小就是 0，查询第 k 小时应改为查询第 k-1 小。第二个前提是，重建后的所有 base[i] 最高位不相同，且通过适当排列后，向量之间没有包含关系。此时按枚举的从小到大自然形成了一个二维矩阵，第 k 小的查询会和二进制位一一对应。
3.3 判断某个数能否被表示
除了求最大和求第 k 小，一个更基础的问题是：给定一个数 y，判断原数组的某个子集能否异或出 y。
判断方法和插入一模一样。把 y 从高位到低位往下走，遇到第 i 位是 1 时就异或上 base[i]，最后如果 y 变成 0，说明能表示；否则不能。这个性质特别适合用在图论题里，比如某些路径异或问题需要判断某个异或值是否可达。
cpp复制bool contain(ll x) {
for (int i = MAXB; i >= 0; --i) {
if ((x >> i & 1) == 0) continue;
if (!base[i]) return false;
x ^= base[i];
}
return x == 0;
}
这里有个细节：如果题目还要求统计有多少种选法能凑出 y，那个答案其实和原数组里冗余元素的数量有关。每个冗余元素都可以选择取或不取，所以方案数还要乘上 2^冗余个数。不过这类计数题通常会暗示取模，如果不取模就会爆 long long，题目描述里会说明。
4. 实际使用时遇到的坑与排查
4.1 为什么最大异或和不能简单地用“线性基里的数都异或一遍”
这是我第一次学线性基时犯过愚蠢错误的地方。看完求最大异或和的网上代码，我以为线性基里所有数都异或起来就是最大结果。这道题在某些形式下可能没错，但请想象数组 [1, 2, 4]。线性基可能是 base[0] = 1, base[1] = 2, base[2] = 4，全部异或得到 7，刚好最大值。但数组 [3, 5, 6] 呢？算一下试试：插入后可能变成 base[1] = 3, base[2] = 5。全部异或成 6，可最大值其实是 5。如果你用 if 判断，5 就是最终答案。核心原因是线性基不是朴素的枚举集合，不能一股脑组合所有向量。
实际比赛里，这种错误非常隐蔽，因为测试数据可能构造得刚好绕过。建议每次求最大值前心里默念一句：不是取所有数的异或，而是像按位 DP 一样，只在能增大答案时才选。
4.2 第 k 小之前必须明白的排序逻辑
另一个坑是,网上有些模板的重构方向反了。求第 k 小时，必须保证“向量的出现顺序”和“二进制拼位后自然形成从小到大”一致。听起来抽象，举两组数据：
数组 [1, 2] 能表示 0、1、2、3，排序后 [1, 2] 的两个基底对应二进制位 0 和 1，二进制的第 2 位对应 vec[1]，第 1 位对应 vec[0]。查询第 1 小 1，第 2 小 2，第 3 小 3，刚好。
数组 [2, 3] 呢？原数组能表示 0、2、3、1。插入后可能得到 base[1] = 2, base[0] = 1？但注意插入顺序会影响结果。如果 base[0] 也是 1，base[1] 却被消可能又变成另一个值。你会发现 base 里不应该同时存在 base[0]=1 和 base[1]=1，否则就退化。重建后的向量就需要从最小基向量开始排。很多模板重建时是从高到低，但最后也只 push low = 0..MAXB 的非空 base，于是当前向量的组合顺序和二进制顺序天然匹配。
稍微多写几句：重建后向量如果为 [1, 4, 5] 这样就不对，因为 5 = 1 ^ 4，违反了“最低的非零位不相交”性质。所以重建不能只是走形式，必须严格循环检查：从低到高位，对每个非空 base[i]，都尝试让比它更高的 base[j] 去掉第 i 位。
4.3 范围与位宽的取舍
第三类坑和位宽有关。小规模数据（n = 100）还好，但一旦 n 大于 1e5，值域最大 1e18，代码里 MAXB 写 63 还是 60，差别不大；但如果值域只有 1e5，MAXB 开到 20 就够，而有人因为习惯直接开 60，导致后续第 k 小计算中 (1LL << cnt) 溢出，最终返回错误结果。
比如数组全是 1e18 范围内的数，线性基最多 60 个非零向量，cnt 最大 60，1LL << 60 是可以存的；但如果 MAXB 写成 63，cnt 可能到 64，1LL << 64 直接溢出变成 0，代码就会永远返回 -1。这类问题调试起来很难一眼发现。
我的建议是把 MAXB 用函数计算：先看输入数最大多少，向上取二进制位。比如最大值不足 1e9，MAXB = 30；不足 1e18，MAXB = 60。写题时直接按输入范围定。另外第 k 小中 if (k >= (1LL << cnt)) 这种判断，cnt 太大也会爆 long long，要考虑用位数判断，例如 if (cnt < 62 && k >= (1LL << cnt))，或者干脆用比大小会变成负数的坑提前规避。
还有一个很常见的错法：没有单独统计是否可以表示 0。如果原数组有重复元素或存在一个数能被其他数异或出来，那么 0 就是可异或出的结果。第 k 小的计数要把 0 算进去。否则样例一过，赛后 WA 就很痛苦。
5. 从原理到模板：给你一个可复用的代码封装
为了让你一下手就能用，我把我自己封装过的 LinearBasis 类放在这里。它在第 k 小查询中进行了重建并兼容 0 的判断，整体逻辑比较踏实。
cpp复制#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct LinearBasis {
static const int MAXB = 60;
ll base[MAXB + 1];
LinearBasis() { memset(base, 0, sizeof(base)); }
bool insert(ll x) {
for (int i = MAXB; i >= 0; --i) {
if (!(x >> i & 1)) continue;
if (!base[i]) {
base[i] = x;
return true;
}
x ^= base[i];
}
return false;
}
void rebuild() {
for (int i = 1; i <= MAXB; ++i) {
if (!base[i]) continue;
for (int j = i - 1; j >= 0; --j) {
if (!base[j]) continue;
if (base[i] >> j & 1) {
base[i] ^= base[j];
}
}
}
}
ll maxXor(ll res = 0) {
for (int i = MAXB; i >= 0; --i) {
if ((res ^ base[i]) > res) res ^= base[i];
}
return res;
}
// 需要调用 rebuild() 之后，才能查询第 k 小
ll kth(ll k, int zeroExist) {
vector<ll> vec;
for (int i = 0; i <= MAXB; ++i) if (base[i]) vec.push_back(base[i]);
int cnt = vec.size();
if (zeroExist) {
if (k == 1) return 0;
--k;
}
if (k >= (1LL << cnt)) return -1;
ll ans = 0;
for (int i = 0; i < cnt; ++i) {
if (k >> i & 1) ans ^= vec[i];
}
return ans;
}
};
这个类最大的好处是把插入、重建、最大查询、第 k 小查询都集中在一起。写题时直接把数组 insert 进去，zeroExist 可以通过 insert 是否有任意一次返回 false 判断，这样查询第 k 小时就不会漏掉 0。
不过这个封装有一个注意事项：kth 函数内部默认调用前你已手动 rebuild。因为第 k 小查询需要的“干净”状态和普通插入状态不一样，每次数据变化后都要重新 rebuild，否则会查询错。你可以在类内部维护一个 dirty 标记，但我为了简洁还是保留手动调用。
6. 我建议的学习顺序与题型判断
很多人找我要线性基的题目练习，我觉得确实有阶梯。第一个阶段是先手写插入和求最大，找几道上古题做；第二个阶段是实现 rebuild 后求第 k 小；第三个阶段是把线性基和图论结合，比如路径异或问题。
怎么判断一道题适不适合线性基？我的经验是三个关键词同时出现时基本跑不掉：异或、子集或路径、最大 / 第 k 小 / 是否可表示。如果题目只是问“有没有两个数的异或为某个值”，那可能用 set 更合适。只有出现“选出若干个数”这种组合爆炸语义时，线性基才有用。还有一种特征是范围给得极大，n 到 1e5 甚至更大，而值域位宽有限，这时线性基的 60 个基底优势就会非常明显。
我记得有一道经典模型是：给你一棵树，每条边有权值，求两点路径异或最大值。它先用 DFS 求出每个节点到根的异或前缀，然后发现任意两点路径的异或可以被拆成两个前缀异或，于是问题变成“一堆数里选两个，最大异或是多少”。很多人会误以为需要线性基，实际上线性基只是用来表出子集，而这里只需要“两个数的异或”最大值，直接构建所有前缀的字典树更好。但如果题目变成“选若干个前缀异或”，那就又是线性基的舞台。所以题型辨别很重要，切不可拿着锤子看什么都是钉子。
这种区分想通之后，你对线性基的理解才算真正活过来：它管的是子集异或张成的空间，而不是两两异或查找。两两异或、区间最大异或对，通常有字典树这个更直接的方案；线性基适合的是“任选组合”的指数爆炸问题。
其实很多文章讲线性基会给你一堆线性代数证明。我觉得刚开始不需要看懂所有证明。先背模板，做三五道题，再回头想为什么。等你想明白“一个高位的基底为什么能把低位抹掉”的时候，你已经能自己推出大部分应用了。
在具体比赛时，我还有一个自己的习惯：如果实在判断不出是否要线性基，可以先尝试插入一遍，看输入是否全是线性无关。如果插入过程中数量很快就小于 n，说明确实存在冗余，子集种类很多，此时线性基多半是正解；如果插完 n 个全部返回 true，那就说明每个数都贡献了一个新维度，这时候要么值域跨度极大，要么你该考虑字典树方向。这个判断技巧帮我少走了很多弯路。
平时写代码最好在本地准备好一个整块的 LinearBasis 模板，比赛时直接贴。与不用模板的人相比，能节省大量时间。我更推荐使用 struct 封装，因为多个测试用例时你只要重新声明对象就会自动清空 base，根本不需要 memset 整个数组。
写在最后
我再分享一段经验：很多人学线性基时会一头扎进第 k 小的代码里，卡住两三天。其实如果先弄懂插入和最大查询，把印象建立在“空间向量”上，第 k 小不过是先去除基底之间的纠缠，再像递推组合一样按位取数。我在实际做题里真的遇过几次因为漏判 0 而 WA 到怀疑人生的场景，现在写模板时都会顺手带着 zeroExist 参数。
只要理解了线性基的本质是在压缩异或集合并保持空间不变，后面遇到组合异或题目时，你会有一种“手里拿着利器”的踏实感。希望这篇偏经验的整理能让你少踩几个坑，最好能顺便帮你把代码里的潜在 bug 也提前消灭掉。