https://www.cnblogs.com/downrainsun/p/11228690.html
完成套路：往自己这里搬。
性质：
设数集T的值域范围为[1,2^n−1]。
T的线性基是T的一个子集A={a1,a2,a3,...,an}。
A中元素互相xor所形成的异或集合，等价于原数集T的元素互相xor形成的异或集合。
可以理解为将原数集进行了压缩。
性质
1.设线性基的异或集合中不存在0。
2.线性基的异或集合中每个元素的异或方案唯一，其实这个跟性质1是等价的。
3.线性基二进制最高位互不相同。
4.如果线性基是满的，它的异或集合为[1,2^n−1]。
5.线性基中元素互相异或，异或集合不变。
接下来是题目：
一，洛谷彩灯
给你m个开关，每个开关表示可以控制哪些灯的状态，且状态取反，亮则暗，暗则亮，求多少种不重复的灯亮状态
题解：首先可以知道的是那些开关实际上就是异或操作，那么考虑到不重复，那就想到线性基
线性基性质A中元素互相xor所形成的异或集合，等价于原数集T的元素互相xor形成的异或集合。，同时不出现重复，那接下来就好办了，成功解决不重复问题，就算线性基有多少个数存在，然后2的个数次方就完事
#include <cstdio>
#include <cstring>
#define ll long long
int n,m;
ll d[60];
char s[60];
void add(ll x)
{
for(int i=50;i>=0;i--)
{
if(x&(1ll<<i))
{
if(d[i]==0)
{
d[i]=x;
return;
}
else x^=d[i];
}
}
}
int main()
{
scanf("%d %d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%s",s+1);
ll x=0;
for(int j=1;j<=n;j++)
if(s[n-j+1]=='O')x^=(1ll<<(j-1));
add(x);
}
int ans=0;
for(int i=0;i<=50;i++)
if(d[i]!=0)ans++;
printf("%lld",(1ll<<ans)%2008);
}
luogu：最大xor和路径
大佬讲解：https://www.luogu.org/blog/An-Amazing-Blog/solution-p4151
我的代码
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=200005;
struct enode{int to; ll c;};
bool vis[MAXN];
int num=0,n,m;
ll s[MAXN],g[MAXN];
vector<enode> e[MAXN];
ll read()
{
ll f=1,x=0; char c=getchar();
while (c<'0'||c>'9') { if (c=='-') f=-1; c=getchar(); }
while (c>='0'&&c<='9') { x=(x<<3)+(x<<1)+c-'0'; c=getchar(); }
return x*f;
}
void dfs(int x,int father)
{
//cout<<x<<" "<<s[x]<<endl;
vis[x]=1;
for (int i=0;i<e[x].size();i++)
if (!vis[e[x][i].to])
{
s[e[x][i].to]=s[x]^e[x][i].c;
// printf("%d %d\n",e[x][i].to,s[e[x][i].to]);
dfs(e[x][i].to,x);
}
else if (e[x][i].to!=father) g[++num]=s[x]^s[e[x][i].to]^e[x][i].c;
}
struct Xor_Basis
{
int maxsz;
ll basis[65];
void init(){ memset(basis,0,sizeof basis); maxsz=63;}
bool insert(ll x)
{
for (int i=maxsz;i>=0;i--)
if ((x>>i)&1)
if (basis[i]) x^=basis[i];
else { basis[i]=x; break; }
return x;
}
}QAQ;
int main()
{
QAQ.init();
n=read(),m=read();
for (int i=1;i<=m;i++)
{x
int u=read(),v=read();ll c=read();
e[u].push_back((enode){v,c});
e[v].push_back((enode){u,c});
}
dfs(1,0);
for (int i=1;i<=num;i++) {QAQ.insert(g[i]);}
ll ans=s[n];
for (int i=QAQ.maxsz;i>=0;i--) if ((ans^QAQ.basis[i])>ans) ans^=QAQ.basis[i];
printf("%lld\n",ans);
return 0;
}
cf的http://codeforces.com/problemset/problem/724/G:
https://blog.csdn.net/u013534123/article/details/79914683
题意其实就是一个u到v的多条路径每条路径的值是边的异或和，贡献是这些多条路径的和，当然重复的不算，因为题目规定的是三元组（u，v，s）。题中要注意的是图是不一定连在一起的，也就是可能有多个连分块。
好的，接下来题解：
简单暴力两个点肯定直接扑街；
我们知道u到v，肯定是由一条路径+若干个环组成（可见上面的大佬讲解博客）；
所以，我们按位来计算贡献，一个位要产生贡献，那么该位最后肯定得是1，（因为本来是0的话，就是没有值，，莫得贡献），所以我们有以下两个方案
当一个起点u和终点v的i位相同，（这里的起点终点是1到u路径与1到v的路径），因为你算u到v肯定是这两个路径异或嘛，所以如果这两个i位相同也就是木有贡献，我们要让这个i位有贡献，就让他经过一个环，环我们已经处理好丢到线性基里了
然后我们找线性基里有没有i位位1的，有的话同时他只有一个（线性基性质），（再次解释下线性基可以保证不会出现重复方案且0的方案），接下来在线性基其他位就可以生成选或不选方案（正因为线性基不会重复，所以我们可以直接2的r-1次方，-1是因为那个i位为1的已经被选了）；
那终点和起点怎么弄呢，没错，每次我们对这些路径进行每一位的计算，cnt【0】（i位为0）有多少个，cnt[1]有多少个。
然后组合数tmp=cnt[0]*(cnt[0]-1)/2+cnt[1]*(cnt[1]-1)/2;
接下来是当起点和终点不一样时的方案：、起点和终点第i位不同，这意味着中间不能经过第i位位1的环。还是一样，看是否有这样的环。如果有，则除了这个环不能取，其他任意，对应2^(r-1)种方案；如果没有那么所有r个向量都可以任意，对应2^r种方案。
记住，我们刚才计算的只是方案数tmp，所以我们更新答案就得再乘上2^i,因为在i位上表示的就是这个值的贡献嘛，所以你的方案数得乘上值才是答案。
#include<bits/stdc++.h>
#define mod 1000000007
#define LL long long
#define N 500010
using namespace std;
struct Linear_Basis
{
LL b[63],nb[63],tot;
void init()
{
tot=0;
memset(b,0,sizeof(b));
memset(nb,0,sizeof(nb));
}
bool ins(LL x)
{
for(int i=62;i>=0;i--)
if (x&(1LL<<i))
{
if (!b[i]) {b[i]=x;break;}
x^=b[i];
}
return x>0;
}
LL Max(LL x)
{
LL res=x;
for(int i=62;i>=0;i--)
res=max(res,res^b[i]);
return res;
}
LL Min(LL x)
{
LL res=x;
for(int i=0;i<=62;i++)
if (b[i]) res^=b[i];
return res;
}
void rebuild()
{
for(int i=62;i>=0;i--)
for(int j=i-1;j>=0;j--)
if (b[i]&(1LL<<j)) b[i]^=b[j];
for(int i=0;i<=62;i++)
if (b[i]) nb[tot++]=b[i];
}
LL Kth_Max(LL k)
{
LL res=0;
for(int i=62;i>=0;i--)
if (k&(1LL<<i)) res^=nb[i];
return res;
}
} LB;
LL s[N],w[N],loop[N],cnt[2],ans;
struct Edge{int y;LL w;};
vector<Edge> g[N];
vector<int> p;
int n,m,r,tot;
bool v[N];
void dfs(int x)
{
v[x]=1;
for(int i=0;i<g[x].size();i++)
{
int y=g[x][i].y;
LL w=g[x][i].w;
if (!v[y])
{
s[y]=s[x]^w,dfs(y);
p.push_back(y);
} else loop[++tot]=s[y]^s[x]^w;
}
}
LL qpow(LL a,LL b)
{
LL ans=1;
while(b)
{
if(b&1)ans=ans*a%mod;
a=a*a%mod; b>>=1;
}
return ans;
}
void calc()
{
for(int i=0;i<=62;i++)
{
bool flag=0;
cnt[0]=cnt[1]=0;
for(int j=0;j<p.size();j++)
cnt[(s[p[j]]>>i)&1]++;
LL tmp=cnt[0]*(cnt[0]-1)/2+cnt[1]*(cnt[1]-1)/2; tmp%=mod;// //起点终点第i位相同的方案数
// for(int j=0;j<=62;j++) if (LB.b[j]&(1LL<<i)) {flag=1;break;}// //判断是否有向量第i位为1
for(int j=0;j<=62;j++) if ((LB.b[j]>>i)&1) {flag=1;break;}// //判断是否有向量第i位为1
if (flag)
{
if (r) tmp=tmp*qpow(2,r-1)%mod;// //如果有那么统计
ans=(ans+tmp*qpow(2,i)%mod)%mod;
}
tmp=cnt[0]*cnt[1]%mod;// //起点和终点第i为不同的方案数
if (flag)//
{
if (r) tmp=tmp*qpow(2,r-1)%mod;
}
else tmp=tmp*qpow(2,r)%mod;
ans=(ans+tmp*qpow(2,i)%mod)%mod;
}
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
ans=0;
for(int i=1;i<=m;i++)
{
int u,v; LL p;
scanf("%d%d%lld",&u,&v,&p);
g[u].push_back(Edge{v,p});
g[v].push_back(Edge{u,p});
}
for(int i=1;i<=n;i++)
if (!v[i])
{
LB.init(); p.clear();// // //不同连通分量的东西不能够混用
tot=r=0; p.push_back(i); dfs(i);
for(int j=1;j<=tot;j++) LB.ins(loop[j]);
for(int j=0;j<=62;j++) if (LB.b[j]) r++;
calc();
}
printf("%lld\n",ans);
}
}