线性基

最新推荐文章于 2020-01-29 07:51:08 发布

denglianna3224

最新推荐文章于 2020-01-29 07:51:08 发布

阅读量88

点赞数

原文链接：http://www.cnblogs.com/downrainsun/p/11228690.html

版权

http://codeforces.com/problemset/problem/724/G

https://blog.sengxian.com/algorithms/linear-basis

https://www.cnblogs.com/ljh2000-jump/p/5869991.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.线性基中元素互相异或，异或集合不变。

维护
插入
如果向线性基中插入数x，从高位到低位扫描它为1的二进制位。
扫描到第i时，如果ai不存在，就令ai=x否则x=x⊗ai。
x的结局是，要么被扔进线性基，要么经过一系列操作过后，变成了0。

合并

将一个线性基暴力插入另一个线性基即可。

L_B merge(const L_B &n1,const L_B &n2)
{
    L_B ret=n1;
    for (int i=0;i<=60;i++)
        if (n2.d[i])
            ret.insert(n2.d[i]);
    return ret;
}

插入x|判断x是否存在

从高位到低位枚举所有位数，如果x的第i位有值：如果a[i]不存在，则a[i]=x，并退出。

　　　　　　　　　　　　　如果a[i]存在，令x^=a[i]。如果最后x变成了0，那么说明x在线性基内。

inline bool insert(int x)
{
    for(int i=nmr;i>=0;i--)
    {
        if(x&(1LL<<i))
        {
            if(a[i]==0)
            {
                a[i]=x;
                break;
            }
            x^=a[i];
        }
    }
    return x>0;
}

查询最大值

从高位到低位扫描线性基。如果异或之后答案变大，就把这一位异或到答案。

inline int get_max()
{
    int ans=0;
    for(int i=nmr;i>=0;i--)
    { 
        if((ans^a[i])>ans)
            ans^=a[i];
    }
    return ans;
}

查询最小值

从低位到高位扫描线性基。最低位上的线性基即为答案。

inline int get_min()
{
    for(int i=0;i<=nmr;i++)
        if(a[i]>0) return a[i];
}

第k小

首先我们要改造一下线性基。我们把线性基改造成每一位相互独立，意思就是对于第i位，

线性基上只有第i位可能是1。（其它位是1就不相互独立了（互相异或不对了））具体如何改造，就是从高位向低位扫描，

对于第i位线性基a[i]，对于j<i，如果a[i]的第j位是1，就让a[j]异或上a[i]。

查询的时候，将k进行二进制拆分，对于的1位，就异或对应的线性基。

最终得到的答案是第k小值。

inline void rebuild()
{
    cnt=0;
    for(int i=nmr;i>=0;i--)
    {
        for(int j=i-1;j>=0;j--)
            if(a[i]&(1LL<<j))
                a[i]^=a[j];
    }
    for(int i=0;i<=nmr;i++)
        if(a[i])
            p[cnt++]=a[i];
}
inline int query(int k)
{
    int ans=0;
    if(k>=(1LL<<cnt)) return -1;
    for(int i=nmr;i>=0;i--)
    {
        if(k&(1LL<<i))
            ans^=p[i];
    }
    return ans;
}

https://www.luogu.org/problemnew/show/P3812

注意异或之后的结果比大小时要加括号！！！！！！！！！！！！

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
ll n;
ll ans;
ll p[70];

void inset(ll x) {
    for(int i = 61; i >= 0; i--) {
        if(x & (1LL << (ll)i)) {
            if(p[i] == 0) {
                p[i] = x;
                break;
            }
            x ^= p[i];
        }
    }
}

int main( ) {
    scanf("%lld", &n);
    ll x;
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &x);
        inset(x);
    }
    for(int i = 61; i >= 0; i--) {
        if((ans ^ p[i]) > ans) ans ^= p[i];
    }
    printf("%lld\n", ans);
    return 0;
}

关于线性基的学习与理解

1、线性基：

　　若干数的线性基是一组数a1,a2,...an

　　通过线性基中元素xor

2、线性基的构造法：

　　对每一个数p

3、查询：

　　用线性基求这组数xor

4、判断：

　　用线性基求一个数能否被xor

个人谈一谈对线性基的理解:

　　很多情况下，只要有关异或运算和求最值，就可以用到线性基。线性基有很多很好的性质，比如说如果有很多个数，我们可以构出这些数的线性基，那么这个线性基可以通过互相xor

　　构造的方法有点像贪心，从大到小保证高位更大。也比较好理解。就是这几行代码：

for(int i=1;i<=n;i++) {    
 
    　　　　for(int j=62;j>=0;j--) {
 
        　　　　 if(!(a[i]>>j)) continue;//对线性基的这一位没有贡献           
 
        　　　　　 　if(!p[j]) { p[j]=a[i]; break; }//选入线性基中                   
 
        　　　　　　 a[i]^=p[j];
 
        　　　　 }
 
    　　　}

　　可以把n

　　查询的话，也是一个贪心思想，如果可以使得ans

　　 1 for(int i=62;i>=0;i--) if((ans^p[i])>ans) ans=ans^p[i];//从线性基中得到最大值

　　这就是线性基的基本用法和个人的一些理解。

下面看一些练习（例题）：

1、BZOJ2460

Description

相传，在远古时期，位于西方大陆的 Magic Land 上，人们已经掌握了用魔法矿石炼制法杖的技术。那时人们就认识到，一个法杖的法力取决于使用的矿石。
一般地，矿石越多则法力越强，但物极必反：有时，人们为了获取更强的法力而使用了很多矿石，却在炼制过程中发现魔法矿石全部消失了，从而无法炼制出法杖，这个现象被称为“魔法抵消” 。特别地，如果在炼制过程中使用超过一块同一种矿石，那么一定会发生“魔法抵消”。
后来，随着人们认知水平的提高，这个现象得到了很好的解释。经过了大量的实验后，著名法师 Dmitri 发现：如果给现在发现的每一种矿石进行合理的编号（编号为正整数，称为该矿石的元素序号），那么，一个矿石组合会产生“魔法抵消”当且仅当存在一个非空子集，那些矿石的元素序号按位异或起来为零。（如果你不清楚什么是异或，请参见下一页的名词解释。）例如，使用两个同样的矿石必将发生“魔法抵消”，因为这两种矿石的元素序号相同，异或起来为零。
并且人们有了测定魔力的有效途径，已经知道了：合成出来的法杖的魔力等于每一种矿石的法力之和。人们已经测定了现今发现的所有矿石的法力值，并且通过实验推算出每一种矿石的元素序号。
现在，给定你以上的矿石信息，请你来计算一下当时可以炼制出的法杖最多有多大的魔力。

正解：贪心+线性基

解题报告：

　　显然这道题可以用线性基来维护一个我们选取的非空子集中不存在异或出0

贪心，按照value从大到小排序然后往线性基里插入就可以得到答案
下面我们来证明（伪）一下
我们先进行排序，编号为a[1]到a[n]，价值为v[1]到v[n]
首先证明a[1]一定在答案里
这里用反证
假设答案为a[k1],a[k2]，……,a[km]
a[1]不在里面说明a[1]可以被一些线性表示
即a[1]=a[ki1]^a[ki2]^……^ a[kix]
那么我们可以用a[1]替换右边的另外一个，使得所有的线性无关
又a[1]的价值大于右边任意一个，因此a[1]必定在答案里
接下来考虑a[j]
如果a[j]可以被a[1]到a[j-1]中的数线性表示，那么a[j]肯定不优，不加入答案
此时即a[j]无法插入到线性基里面
如果a[j]不能被a[1]到a[j-1]中的数线性表示，即a[j]可以被插入线性基里
那么如果a[j]不在答案，那么a[j]必定可以被a[1]到a[j-1]与a[j+1]到a[n]中的数线性表示
其中a[j+1]到a[n]中至少存在一个
那么我们用a[j]替换这个数，可以使得所有数的异或不为0
又a[j]的价值一定比a[j+1]到a[n]中的任意一个大
因此a[j]如果能够插入线性基，就一定会在答案里
综上我们只需要按照value从大到小排序后依次插入线性基，把能够插入的累加到ans里即可

#include<bits/stdc++.h>
using namespace std;
struct magic
{
    long long x;
    int v;
    bool operator <(magic y) const
    {
        return v>y.v;
    }
}a[1001];
int n,cnt;
long long p[64],d[64];
long long ans;
inline void guass()
{
    memset(d,0,sizeof(d));
    int i,j;
    for(i=1;i<=n;i++)
    {
        for(j=63;j>=0;j--)
        {
            if((a[i].x>>j)&1)
            {
                if(d[j])
                    a[i].x^=d[j];
                else
                {
                    d[j]=a[i].x;
                    ans+=a[i].v;
                    break;
                }
            }
        }
    }
}
int main()
{
    scanf("%d",&n);
    int i;
    for(i=1;i<=n;i++)
        scanf("%lld%d",&a[i].x,&a[i].v);
    sort(a+1,a+1+n);
    guass();
    printf("%lld\n",ans);
    return 0;
}

2、BZOJ2115

Description

正解：线性基

解题报告：

　　这道题要求从1到n的最大xor和路径，存在重边，允许经过重复点、重复边。那么在图上作图尝试之后就会发现，路径一定是由许多的环和一条从1到n的路径组成。容易发现，来回走是没有任何意义的，因为来回走意味着抵消。考虑这道题求得是路径xor和最大，所以必然我们要想办法处理环的情况。我的做法是任意地先找出一条从1到n的路径，把这条路径上的xor和作为ans初值（先不管为什么可行），然后我们的任务就变成了求若干个环与这个ans初值所能组合成的xor最大值。显然，我们需要预处理出图上所有的环，并处理出所有环的环上xor值，这当然是dfs寻找，到n的路径的时候顺便求一下就可以了。

　　当我们得到了若干个环的xor值之后，因为是要求xor最大值，我们就可以构出这所有xor值的线性基。构出之后，再用ans在线性基上取max就可以了。

　　现在我们来讨论上述做法的可行性。

　　第一种情况：我们对最终答案产生贡献的某个环离1到n的主路径很远，这样的话，因为至少可以保证1可以到达这个环，那么我们可以走到这个环之后绕环一周之后原路返回，这样从1走到环的路上这一段被重复经过所以无效，但是环上的xor值被我们得到了，所以我们并不关心这个环和主路径的关系，我们只关心环的权值。

　　第二种情况：我们任意选取的到n的路径是否能保证最优性。假设存在一条更优的路径从1到n，那么这条路径与我们原来的路径构成了一个环，也就会被纳入线性基中，也会被计算贡献，假如这个环会被经过，那么最后的情况相当于是走了两遍原来选取的路径，抵消之后走了一次这个最优路径，所以我们无论选取的是哪条路径作为ans初值，都可以通过与更优情况构成环，然后得到一样的结果。这一证明可以拓展到路径上的任意点的路径选取。

　　这样我们就可以完美解决了。我第一次WA了一发，因为我没有考虑到ans初值不为0，在线性基上取到xor的max的时候，不能单纯以ans这一位是否为0来决定是否异或上基的这一位，必须要看异或之后取一个max做一个判断才行。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N = 5e4 + 5;
const int M = 1e5 + 5;
int n,m,cnt,vis[N];
ll d[N],p[64],a[M*4];
struct node{
    int v;
    ll w;
};
vector<node> G[N];

void dfs(int u)
{
    vis[u] = 1;
    for(int i = 0;i < G[u].size();i++)
    {
        int v = G[u][i].v;ll w = G[u][i].w;
        if(!vis[v])
        {
            d[v] = d[u]^w;
            dfs(v);
        }
        else
            a[++cnt] = d[v]^d[u]^w;
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    int u,v;ll w;
    while(m--)
    {
        scanf("%d%d%lld",&u,&v,&w);
        G[u].push_back({v,w});
        G[v].push_back({u,w});
    }
    dfs(1);
    for(int i = 1;i <= cnt;i++)
    {
        for(int j = 62;j >= 0;j--)
        {
            if(!(a[i] >> j)) continue;
            if(!p[j]){
                p[j] = a[i];
                break;
            }
            a[i] ^= p[j];
        }
    }
    ll ans = d[n];
    for(int i = 62;i >= 0;i--)
        if((ans^p[i]) > ans)
            ans = ans ^ p[i];
    printf("%lld\n",ans);
    return 0;
}

3、codeforces724G

　　直接链接到我的那篇博客过去辣

转载于:https://www.cnblogs.com/downrainsun/p/11228690.html

denglianna3224

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线性基

http://codeforces.com/problemset/problem/724/Ghttps://blog.sengxian.com/algorithms/linear-basishttps://www.cnblogs.com/ljh2000-jump/p/5869991.html转载设数集T的值域范围为[1,2^n−1]。T的线性基是T...
复制链接

扫一扫