线性基学习笔记

已于 2024-02-23 21:55:30 修改
阅读量746 收藏 22
点赞数 23
分类专栏： 信息竞赛学习笔记 文章标签： 笔记 c++ 数据结构
于 2024-02-23 21:43:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dyc780511/article/details/136264150
版权

线性基学习笔记

定义

线性空间 V V V 内的一个极大线性无关组是 V V V 的一组 hamel 基 或 线性基，简称 基。

以上内容是 OI WIKI 中提及的定义。

更具体一点来说，对于一个向量组 v v v，如果满足对于任意的取值，使 ∑ i = 1 n α i v i ≠ 0 \sum_{i=1}^n\alpha_iv_i\ne0 ∑i=1n​αi​vi​=0（ α \alpha α 是常数），即不回到原点，那么称这个向量组是线性无关的。而一个极大线性无关组，对于一个 n n n 维空间来说，通常有 n n n 个元素，并且再加入任意一个元素都会使向量组 v v v 线性相关，即可以回到原点。对于任意的 α \alpha α， ∑ i = 1 n α i v i \sum_{i=1}^n\alpha_iv_i ∑i=1n​αi​vi​ 一定可以表示出整个空间内的任何一个点。

这些都是从几何层面上考虑。一个线性基说明我们可以用一种根简单更直观的方式来表示所有原集合中的内容。在 C++ 中包括实数线性基和异或线性基，而最常出现的是异或线性基。

异或线性基

和普通线性基一样的，异或线性基相当于将加法运算代替为异或运算，所以由定义可知异或线性基内的任意元素的异或值均不为 0 0 0。

异或线性基通常被用来求解集合内的异或 k k k 大值。

操作

添加元素

线性基的构造有两种方法，一种是动态的贪心构造，一种是静态的高斯消元构造。

贪心
void insert(ull x){
	for(int i=50;~i;i--){
		if(!(x>>i))continue;
		if(!d[i]){
			d[i]=x;
			break;
		}
		x^=d[i];
	}
	return ;
}
高斯消元
void gauss(){
	int j,k=1;
	for(int i=50;~i;i--){
		for(j=k;j<=n;j++){
			if(d[j]&(1ll<<i))break;
		}
		if(j>n)continue;
		swap(d[j],d[k]);
		for(j=1;j<=n;j++){
			if(j!=k&&d[j]&(1ll<<i))d[j]^=d[k];
		}
		k++;
	}
	k--;
	return ;
}

两种方法的复杂度都是 O ( n log ⁡ a ) O(n\log a) O(nloga)，其中 a a a 表示值域。高斯消元的常数更大，并且只适用于静态，因此不常选用。

这样构造出的线性基， d i d_i di​ 所表示的线性基的第 i i i 位一定是 1 1 1，第 i i i 位以前的一定是 0 0 0。

查询异或最大值

当然这个问题也适用于下面的异或 k k k 小值问题。

考虑到如果要让异或值最大，那么高位一定要大。又考虑到 d i d_i di​ 的第 i i i 位一定是 1 1 1，那么我们可以贪心，如果高位能够让结果变大，那么就选择异或。

code
long long MaxXor(){
	long long res=0;
	for(int i=62;i>=0;i--)res=max(res,res^d[i]);
	return res;
}
例题【P3505. [luogu3812]线性基模板】

没什么好说的，纯纯模板题。

code
#include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long

int n;
ull ans;
ull p[64];

void insert(ull x){
	for(int i=50;~i;i--){
		if(!(x>>i))continue;
		if(!p[i]){
			p[i]=x;
			break;
		}
		x^=p[i];
	}
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		ull a;
		scanf("%llu",&a);
		insert(a);
	}
	for(int i=50;~i;i--)ans=max(ans,ans^p[i]);
	printf("%llu",ans);
	return 0;
}

查询异或最小值

这个问题也可以类比到异或 k k k 小值。

考虑和刚才一样的思路，但是我们发现，如果有元素插入失败，则说明异或值可以为 0 0 0，但由于线性基的定义导致了线性基内元素的异或值不可能为 0 0 0，因此需要特判，反之，输出有确切值的最小的线性基。

code
int MinXor(){
	if(tot<n)return 0;
	for(int i=0;i<=62;i++){
		if(d[i])return d[i];
	}
}

查询异或 k k k 小值

和刚才一样考虑，我们发现，可以让对应二进制位的线性基异或，即如果 k k k 的二进制的第 i i i 位为 1 1 1，那么就让结果异或第 k k k 大的有值的线性基。但如果这个样子，可能会因为之前的某一位上已经有了 1 1 1 而造成结果减小。为了保证这种情况不发生，我们应该保证如果第 i i i 个线性基有值，那么第 i i i 位有且仅有这一个线性基为 1 1 1。于是我们考虑像高斯消元一样重构。接着重复刚才的操作即可（注意特判 0 0 0）。

code
void Rebuild(){
    for(int i=0;i<=62;i++){
        for(int j=i-1;j>=0;j--)d[i]=min(d[i],d[i]^d[j]);
    }
    return ;
}
例题【P575. [bzoj2844]albus就是要第一个出场】

先考虑问题在不可重集下的的情况，那么为了知道某个数的第一次出现的位置，我们可以二分出一个位置，如果过大则向前，过小则向后。现在考虑问题在可重集下的情况。如果线性基内有 ∣ S ∣ |S| ∣S∣ 个元素，那么说明剩下的 n − ∣ S ∣ n-|S| n−∣S∣ 个元素一定都与线性基内的某些元素异或值为 0 0 0。不妨将外面的元素均看为 0 0 0，如此一来，不管外面的元素选择什么，得到的异或值都不变 ，因此每个元素都会重复 2 n − ∣ S ∣ 2^{n-|S|} 2n−∣S∣ 次，并且，因为可以选择空集，所以异或值的集合里一定包含了 0 0 0。最后二分出答案算出该组元素的第一个的下标即可。

code
#include <bits/stdc++.h>
using namespace std;
#define ll long long

const int M=10086;
int n,x,Q,tot;
int d[32],arr[32];

void ins(int x){
    for(int i=30;i>=0;i--){
        if(((x>>i)&1)==0)continue;
        if(!d[i]){
            d[i]=x;
            break;
        }
        x^=d[i];
    }
    return ;
}

void rebuild(){
    for(int i=0;i<=30;i++){
        for(int j=i-1;j>=0;j--){
            if((d[i]>>j)&1)d[i]^=d[j];
        }
    }
    for(int i=0;i<=30;i++){
        if(d[i])arr[tot++]=i;
    }
    return ;
}

int kth(int k){
    int res=0;
    for(int i=tot-1;i>=0;i--){
        if((k>>i)&1)res^=d[arr[i]];
    }
    return res;
}

ll QuickPow(ll a,int b){
    ll res=1;
    while(b){
        if(b&1)res=res*a%M;
        a=a*a%M;
        b>>=1;
    }
    return res;
}

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        ins(x);
    }
    rebuild();
    scanf("%d",&Q);
    ll l=0,r=(1<<tot)-1,ans=0;
    while(l<=r){
        ll mid=(l+r)>>1;
        if(kth(mid)>=Q){
            ans=mid;
            r=mid-1;
        }else l=mid+1;
    }
    printf("%lld",(ans%M*QuickPow(2,n-tot)%M+1)%M);
    return 0;
}

线性基合并

是的，线性基可以合并，只需要将一个线性基内的元素插入到另一个线性基内即可，时间复杂度是 O ( log ⁡ 2 a ) O(\log^2 a) O(log2a)。

void merge(LineBasis x,LineBasis y){
    for(int i=62;i>=0;i--)x.ins(y.d[i]);
    return ;
}

区间异或最大值

可以类比为区间异或 k k k 大值，本质上只需要求出区间的线性基即可。

考虑和 RMQ 相同的思路，因为线性基内插入相同元素会插入失败，从而不影响结果，因此可以通过倍增求解连续 2 k 2^k 2k 个元素的线性基，然后利用线性基合并，将整个区间有重的合并在一起。然后求解即可。

例题【P580. [bzoj4568] [Scoi2016]幸运数字】

考虑到求路径上选点权使异或值最大，考虑线性基，只需要得到路径上的所有点权并插入线性基即可，时间复杂度是 O ( q log ⁡ n + q n ) O(q\log n+qn) O(qlogn+qn) 的。考虑到线性基可以合并，那么我们可以利用倍增思想，将自己到自己的第 2 j 2^j 2j 个祖先（不包括第 2 j 2^j 2j 个祖先）的所有点权存储在线性基里面，在求解 LCA 的时候可以一并合并，这样的时间复杂度是 O ( n log ⁡ n log ⁡ 2 a + q log ⁡ n log ⁡ 2 a ) O(n\log n\log^2 a+q\log n\log^2 a) O(nlognlog2a+qlognlog2a)，有一说一似乎比暴力更差。接着可以考虑和区间异或最大值的方法，用两个可重区间将整个区间覆盖，具体方式在于将两个节点到 LCA 的部分分开处理，每个部分相当于一个区间异或最大值，求解即可，复杂度能去掉一个 log ⁡ \log log，是 O ( n log ⁡ n log ⁡ 2 a + q log ⁡ n + q log ⁡ 2 a ) O(n\log n\log^2 a+q\log n+q\log^2 a) O(nlognlog2a+qlogn+qlog2a) 的。

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

const int N=2e4;
int n,m;
long long a[N+5];
struct Graph{
    int cnt;
    int head[N+5],v[(N<<1)+5],to[(N<<1)+5];
    void AddEdge(int x,int y){
        v[cnt]=y;
        to[cnt]=head[x];
        head[x]=cnt++;
        return ;
    }
    void Build(){
        cnt=1;
        int x,y;
        for(int i=1;i<n;i++){
            scanf("%d%d",&x,&y);
            AddEdge(x,y);
            AddEdge(y,x);
        }
        return ;
    }
}G;
struct LineBasis{
    long long d[64];
    void clear(){
        memset(d,0,sizeof d);
        return ;
    }
    void AddNumber(long long x){
        for(int i=60;~i;i--){
            if(((x>>i)&1)==1){
                if(d[i]==0){
                    d[i]=x;
                    break;
                }
                x^=d[i];
            }
        }
        return ;
    }
    void AddLB(LineBasis x){
        for(int i=60;~i;i--)AddNumber(x.d[i]);
        return ;
    }
    void show(){
        for(int i=60;i>=0;i--)printf("%lld ",d[i]);
        printf("\n");
        return ;
    }
};

int Log(int x){
    int res=0;
    while(x){
        res++;
        x>>=1;
    }
    return res-1;
}

struct LCA{
    int l;
    int dep[N+5],faz[N+5][20];
    LineBasis DisXor[N+5][20];
    void Dfs(int x,int fa){
        for(int i=1;i<=l;i++){
            faz[x][i]=faz[faz[x][i-1]][i-1];
            DisXor[x][i].AddLB(DisXor[x][i-1]);
            DisXor[x][i].AddLB(DisXor[faz[x][i-1]][i-1]);
        }
        for(int i=G.head[x];i;i=G.to[i]){
            int y=G.v[i];
            if(y==fa)continue;
            faz[y][0]=x;
            dep[y]=dep[x]+1;
            DisXor[y][0].AddNumber(a[y]);
            Dfs(y,x);
        }
        return ;
    }
    int kth(int x,int k){
        for(int i=l;i>=0;i--){
            if(((k>>i)&1)==0)continue;
            x=faz[x][i];
        }
        return x;
    }
    int lca(int x,int y){
        if(dep[x]<dep[y])swap(x,y);
        x=kth(x,dep[x]-dep[y]);
        if(x==y)return y;
        for(int i=l;i>=0;i--){
            if(faz[x][i]!=faz[y][i]){
                x=faz[x][i];
                y=faz[y][i];
            }
        }
        return faz[y][0];
    }
    void Build(){
        l=Log(n);
        Dfs(1,0);
        return ;
    }
}Lca;
struct Query{
    void Build(){
        int x,y;
        long long ans;
        LineBasis res;
        for(int i=1;i<=m;i++){
            ans=0;
            res.clear();
            scanf("%d%d",&x,&y);
            int lca=Lca.lca(x,y);
            res.AddNumber(a[lca]);
            int Len=Log(Lca.dep[x]-Lca.dep[lca]+1);
            res.AddLB(Lca.DisXor[x][Len]);
            res.AddLB(Lca.DisXor[Lca.kth(x,Lca.dep[x]-Lca.dep[lca]+1-(1<<Len))][Len]);
            Len=Log(Lca.dep[y]-Lca.dep[lca]+1);
            res.AddLB(Lca.DisXor[y][Len]);
            res.AddLB(Lca.DisXor[Lca.kth(y,Lca.dep[y]-Lca.dep[lca]+1-(1<<Len))][Len]);
            for(int i=60;~i;i--)ans=max(ans,ans^res.d[i]);
            printf("%lld\n",ans);
        }
        return ;
    }
}Q;

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
    G.Build();
    Lca.Build();
    Q.Build();
    return 0;
}

奇怪性质

个数固定

正如定义里所说，一个极大线性无关组的大小通常是固定的。所以不管我们怎么插入，这个线性基内元素的个数总是固定的。可以理解为 a 1 ⊕ a 2 = a 3 ⇒ a 1 ⊕ a 3 = a 2 a_1\oplus a_2=a_3\Rightarrow a_1\oplus a_3=a_2 a1​⊕a2​=a3​⇒a1​⊕a3​=a2​。

例题【P574. [bzoj2460] [BeiJing2011]元素】

因为线性基内元素个数是固定的，因此选择贪心，将权值大的尽可能靠前插入，这样得到的权值一定最大。

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

int n,ans;
long long p[64];
struct stone{
	int m;
	long long x;
	friend bool operator <(const stone &a,const stone &b);
}a[1005];

bool operator <(const stone &a,const stone &b){
	return a.m>b.m;
}

bool ins(long long x){
	for(int i=62;~i;i--){
		if(!(x>>i))continue;
		if(!p[i]){
			p[i]=x;
			return 1;
		}
		x^=p[i];
	}
	return 0;
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%lld%d",&a[i].x,&a[i].m);
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++){
		if(ins(a[i].x))ans+=a[i].m;
	}
	printf("%d",ans);
    return 0;
}

练习题

P577. [bzoj3569]DZY Loves Chinese II

这道题需要先想一个奇怪的构造，之后的代码就简单了。首先在图里跑一个 DFS 树，将所有的非树边随机赋一个权值，接着将这条非树边在树上的两个端点之间的简单路径上的所有边的权值均异或上这条非树边的权值。当输入的 k k k 条边存在一些边的边权异或值为 0 0 0，那么这个图不联通。

可以想象成每一个环都拥有不同的权值，当一个环内有两条边被同时去掉，那么这个环便不联通，所以整张图便不联通。但是如果一条边在多个环里，那么只要有一个环只去除了它一条边，那么整张图也是联通的，因为所有的不联通的环的两个部分都分别交于这条边的两个端点，所以它们联通。

这应该是哈希在线性基中的体现。

code
#include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long

const int N=1e5,M=5e5;
int n,m,q,k,cnt,x,ans,tot;
int head[N+5],u[M+5],v[M+5];
ull d[64],w[M+5],a[N+5];
bool vis[N+5],inT[M+5];
mt19937_64 rnd(20100511);
struct edge{
    int to,v,id;
}e[(M<<1)+5];

void AddEdge(int x,int y,int z){
    e[cnt].v=y;
    e[cnt].to=head[x];
    e[cnt].id=z;
    head[x]=cnt++;
    return ;
}

void Dfs(int x){
    vis[x]=true;
    for(int i=head[x];i;i=e[i].to){
        int y=e[i].v,z=e[i].id;
        if(vis[y])continue;
        inT[z]=true;
        Dfs(y);
    }
    return ;
}

void Get(int x,int faz){
    for(int i=head[x];i;i=e[i].to){
        int y=e[i].v,z=e[i].id;
        if(y==faz||!inT[z])continue;
        Get(y,x);
        w[z]=a[y];
        a[x]^=a[y];
    }
    return ;
}

void Insert(int x){
    for(int i=63;i>=0;i--){
        if(((x>>i)&1)==0)continue;
        if(d[i]==0){
            tot++;
            d[i]=x;
            break;
        }
        x^=d[i];
    }
    return ;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&u[i],&v[i]);
        AddEdge(u[i],v[i],i);
        AddEdge(v[i],u[i],i);
    }
    Dfs(1);
    for(int i=1;i<=m;i++){
        if(!inT[i]){
            w[i]=rnd();
            a[u[i]]^=w[i];
            a[v[i]]^=w[i];
        }
    }
    Get(1,0);
    scanf("%d",&q);
    while(q--){
        tot=0;
        for(int i=63;i>=0;i--)d[i]=0;
        scanf("%d",&k);
        for(int i=1;i<=k;i++){
            scanf("%d",&x);
            Insert(w[x^ans]);
        }
        if(tot<k)printf("Disconnected\n");
        else{
            ans++;
            printf("Connected\n");
        }
    }
    return 0;
}

P578. [bzoj4184] shallot

这道题需要用到线性基删除，但事实上，我翻遍了全网，也没有找到任何一个适用于本题的直接删除手段。因此我们考虑，对于每一个元素，都可以分配一个出现的时间和消失的时间，那么这就可以用到线段树分治，而我们只需要在向下遍历的时候将新元素加入线性基即可。

code
#include <bits/stdc++.h>
using namespace std;
#define lid id<<1
#define rid id<<1|1

const int N=5e5;
int n;
int a[N+5];
set<pair<int,int> >pos;
set<pair<int,int> >::iterator it;
stack<int>s;
vector<int>T[N<<2];
struct LineBasis{
    int d[31];
    void Insert(int x){
        for(int i=30;~i;i--){
            if(((x>>i)&1)==1){
                if(d[i]==0){
                    d[i]=x;
                    break;
                }
                x^=d[i];
            }
        }
        return ;
    }
}Lb;

void Build(int id,int l,int r){
    if(l==r)return ;
    int mid=(l+r)>>1;
    Build(lid,l,mid);
    Build(rid,mid+1,r);
    return ;
}

void Insert(int id,int l,int r,int p,int q,int x){
    if(p<=l&&r<=q){
        T[id].push_back(x);
        return ;
    }
    int mid=(l+r)>>1;
    if(p<=mid)Insert(lid,l,mid,p,q,x);
    if(q>mid)Insert(rid,mid+1,r,p,q,x);
    return ;
}

void Dfs(int id,int l,int r,LineBasis x){
    for(int i=0;i<(int)T[id].size();i++)x.Insert(T[id][i]);
    if(l==r){
        int ans=0;
        for(int i=30;~i;i--)ans=max(ans,ans^x.d[i]);
        printf("%d\n",ans);
    }else{
        int mid=(l+r)>>1;
        Dfs(lid,l,mid,x);
        Dfs(rid,mid+1,r,x);
    }
    return ;
}

int main(){
    scanf("%d",&n);
    Build(1,1,n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(a[i]>0)pos.insert(make_pair(a[i],i));
        else{
            it=pos.lower_bound(make_pair(-a[i],0));
            Insert(1,1,n,(*it).second,i-1,-a[i]);
            pos.erase(it);
        }
    }
    for(it=pos.begin();it!=pos.end();it++)Insert(1,1,n,(*it).second,n,(*it).first);
    Dfs(1,1,n,Lb);
    return 0;
}
Dyc780511
关注
  • 23
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性代数 基础入门 学习笔记
04-21
本学习笔记主要基于王东老师和赵海霞老师的教材，由一位大一学生整理，旨在帮助初学者系统地理解和掌握线性代数的基本概念、理论与方法。 线性代数的核心内容包括以下几个方面： 1. 向量与向量空间：向量是线性...
模拟电子技术个人学习笔记
最新发布
05-12
这份个人学习笔记结合了上海交通大学郑益慧教授的网课内容以及作者所在学校的教师资源，是深入理解和掌握模拟电子技术知识的重要参考资料。 笔记中可能涵盖以下关键知识点： 1. **二极管**：二极管是一种单向导电...
线性基详解
热门推荐
a_forever_dream的博客
11-03 3万+
废话 update on 2020.4.6： 大巨巨在评论中指出了以前写的的删除操作有 bugbugbug，仔细思考后稍微修改了一下（然而跟我在评论中写的做法并不一样qwq），并且更新了整篇文章的排版。 线性基是啥？ 线性基是一个数的集合，并且每个序列都拥有至少一个线性基，取线性基中若干个数异或起来可以得到原序列中的任何一个数。 线性基三大性质 原序列里面的任意一个数都可以由线性基里面的一些数...
线性基整理
qq_40052678的博客
10-21 648
概述 线性基，是线性代数中的概念，在信息学竞赛中，前缀线性基是线性基的扩展，他们主要用于处理有关异或和的极值问题。 一组线性无关的向量即可作为一组基底，张起一个线性的向量空间，这个基底即称为线性基，利用线性基的基底进行线性运算，可表示向量空间内的所有向量，换句话说，所有向量都可以拆成基底的线性组合。 根据异或的原理，将一个数字拆成他的二进制形式，将二进制形式用向量来表示，由于一组线性无关的向量可以张起一个向量空间，因此可以考虑构造这样一组数字的二进制形式组成的线性基，在这个线性基中，通过基底的线性组合、异或
【数论】线性基
zsjzliziyang的博客
08-22 1722
所谓线性基，就是线性代数里面的概念。一组线性无关的向量便可以作为一组基底，张起一个线性的向量空间，这个基地又称之为线性基。这个线性基的基底进行线性运算，可以表示向量空间内的所有向量，也即所有向量可以拆成基底的线性组合。 在ACM领域，线性基主要用来处理有关异或和的极值问题。根据异或按照二进制数位进行的方式，我们可以把一个数字拆成它的二进制表示形式，而这个二进制形式拆成一位一位...
线性基 学习笔记
sophilex的博客
02-16 517
什么是线性基？先来回顾一下向量空间中的基。这个基代表着空间的一个极大线性无关子集，组中向量线性无关，且空间中的任意一个向量都可以唯一地由基中的向量来表示那么回到线性基，它其实就类似于是一个向量空间的基我们考虑一个问题：给定一个数组a，要求一个最小的数组d，使得a中的任意一个数可以由d中的若干个数字来通过异或得到，且d中任意多个数字的异或结果不为0注意到异或操作其实就是在模2意义下的加法操作，我们如果将每一个数字按二进制位分解，就可以看成一个n维向量（我们假定数字
线性基详解+例题
L_X_
03-04 563
线性基 何为线性基？DEFINE：对于一个向量的集合，我们可以得到至少一个基向量集合，这个基向量集合就是线性基。线性基内的一个或多个基向量进行异或操作总能得到原向量集合中的向量。 性质 原集合中的任何一个数都可以由线性基中的一些数异或得到 线性基中任意一些数异或都不能得到0 线性基大小唯一。也就是基向量的个数唯一。 一个集合可以有多个大小相同但基向量不完全相同的线性基。 如何得到线...
线性代数笔记1
08-03
基和关于基的坐标是描述向量空间的关键工具，任何向量都可以用基向量的线性组合表示。内积是向量空间中定义的一种二元运算，它提供了一种衡量向量之间“相似性”的方式，具有对称性、反对称性和正定性等重要性质。...
MIT线性代数笔记.zip
07-06
《MIT线性代数笔记》是一份深入探讨线性代数基础理论与应用的资源，由麻省...MIT的这份笔记以其严谨和清晰的阐述，为学习者提供了深入理解线性代数的宝贵资源。通过仔细研读和实践，可以提升对这个重要数学分支的掌握。
详细的麻省线性代数笔记
04-04
麻省理工学院（MIT）的线性代数课程因其深入浅出的教学方式而备受推崇，其笔记更是学习者的重要参考资料。 首先，我们要理解线性代数的基础概念，包括向量、矩阵、行列式和线性方程组。向量可以看作是有方向和大小...
线性基
JCC
03-18 2630
什么是线性基 在线性代数里面我们其实已经学过线性基了，类似极大线性无关组和空间的基，一组线性无关的向量，可以构建一个向量空间，这组线性无关的向量就构成了这个空间的一个基地，这个基地就是线性基。 线性基的意义 线性基是一种特殊的基，它通常会在异或运算中出现，它的意义是：假设若干数的线性基是一组数a1,a2,...an，其中ax的最高位的1在第x位。并且通过原集合S的某一个最小子集S1使得S1内元...
线性基简介
andyc_03的博客
06-02 1050
【算法简介】 线性基是向量空间的一组基，通常可以解决有关异或的一些题目。 通俗一点的讲法就是由一个集合构造出来的另一个集合，它有以下几个性质： 线性基的元素能相互异或得到原集合的元素的所有相互异或得到的值。 线性基是满足性质 1 的最小的集合。 线性基没有异或和为 0 的子集。 线性基中每个元素的异或方案唯一，也就是说，线性基中不同的异或组合异或出的数都是不一样的。 线性基中每个元素的二进制最高位互不相同。 【构造方法】 采取增量构造的方式，把一个新加
Reinforcement Learning: An Introduction Second Edition - Chapter 9
weixin_44909139的博客
11-27 285
图书《强化学习》第九章读书笔记。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值