线性基专题

最新推荐文章于 2021-07-16 19:41:47 发布
最新推荐文章于 2021-07-16 19:41:47 发布
阅读量238 收藏
点赞数
分类专栏： 线性基
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45483201/article/details/113005371
版权

线性基

P3812 【模板】线性基

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct linearbasis {
    ll base[64], flag, cnt;

    void add(ll x) {
        for(int i = 62; ~i; i--) {
            if(x >> i & 1) {
                if(!base[i]) {
                    base[i] = x;
                    return ;
                }
                x ^= base[i];
            }
        }
        flag = 1;
    }

    ll query_max() {
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if((ans ^ base[i]) > ans) {
                ans ^= base[i];
            }
        }
        return ans;
    }

    ll query_min() {
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                return base[i];
            }
        }
    }

    void rebuild() {
        cnt = 0;
        for(int i = 62; i >= 0; i--) {
            for(int j = i - 1; j >= 0; j--) {
                if(base[i] >> j & 1) {
                    base[i] ^= base[j];
                }
            }
        }
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                ll temp = base[i];
                base[i] = 0;
                base[cnt++] = temp;
            }
        }
    }

    ll query_k(ll k) {
        k -= flag;
        if(k == 0) return 0;
        if(k >= 1ll << cnt) return -1;
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if(k >> i & 1) {
                ans ^= base[i];
            }
        }
        return ans;
    }
    void init() {
        memset(base, 0, sizeof base), flag = cnt = 0;
    }
}a;

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    ll x; cin >> x;
    a.add(x);
  }
  printf("%lld\n", a.query_max());
  return 0;
}

G. Shortest Path Problem?

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 2e5 + 10;

int head[N], to[N], nex[N], value[N], cnt;

int dis[N], vis[N], n, m;

struct linearbasis {
  ll base[64], flag, cnt;

  void add(ll x) {
    for(int i = 62; ~i; i--) {
      if(x >> i & 1) {
        if(!base[i]) {
            base[i] = x;
            return ;
        }
        x ^= base[i];
      }
    }
    flag = 1;
  }

  ll query_max() {
    ll ans = 0;
    for(int i = 62; ~i; i--) {
      if((ans ^ base[i]) > ans) {
          ans ^= base[i];
      }
    }
    return ans;
  }

  ll query_min() {
    for(int i = 0; i <= 62; i++) {
      if(base[i]) {
          return base[i];
      }
    }
  }

  void rebuild() {
    cnt = 0;
    for(int i = 62; i >= 0; i--) {
      for(int j = i - 1; j >= 0; j--) {
        if(base[i] >> j & 1) {
          base[i] ^= base[j];
        }
      }
    }
    for(int i = 0; i <= 62; i++) {
      if(base[i]) {
        ll temp = base[i];
        base[i] = 0;
        base[cnt++] = temp;
      }
    }
  }

  ll query_k(ll k) {
    k -= flag;
    if(k == 0) return 0;
    if(k >= 1ll << cnt) return -1;
    ll ans = 0;
    for(int i = 62; ~i; i--) {
      if(k >> i & 1) {
        ans ^= base[i];
      }
    }
    return ans;
  }

  ll solve() {
    ll ans = dis[n];
    for (int i = 62; i >= 0; i--) {
      if ((ans ^ base[i]) < ans) {
        ans ^= base[i];
      }
    }
    return ans;
  }

  void init() {
    memset(base, 0, sizeof base), flag = cnt = 0;
  }
}a;

void add(int x, int y, int w) {
  to[cnt] = y;
  nex[cnt] = head[x];
  value[cnt] = w;
  head[x] = cnt++;
}

void dfs(int rt, int w) {
  vis[rt] = 1, dis[rt] = w;
  for (int i = head[rt]; i; i = nex[i]) {
    if (vis[to[i]]) {
      a.add(w ^ dis[to[i]] ^ value[i]);
    }
    else {
      dfs(to[i], w ^ value[i]);
    }
  }
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= m; i++) {
    int x, y, w;
    scanf("%d %d %d", &x, &y, &w);
    add(x, y, w);
    add(y, x, w);
  }
  dfs(1, 0);
  printf("%lld\n", a.solve());
  return 0;
}

[WC2011]最大XOR和路径

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct linearbasis {
    ll base[64], flag, cnt;

    void add(ll x) {
        for(int i = 62; ~i; i--) {
            if(x >> i & 1) {
                if(!base[i]) {
                    base[i] = x;
                    return ;
                }
                x ^= base[i];
            }
        }
        flag = 1;
    }

    ll query_max(ll ans = 0) {
        for(int i = 62; ~i; i--) {
            if((ans ^ base[i]) > ans) {
                ans ^= base[i];
            }
        }
        return ans;
    }

    ll query_min() {
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                return base[i];
            }
        }
    }

    void rebuild() {
        cnt = 0;
        for(int i = 62; i >= 0; i--) {
            for(int j = i - 1; j >= 0; j--) {
                if(base[i] >> j & 1) {
                    base[i] ^= base[j];
                }
            }
        }
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                ll temp = base[i];
                base[i] = 0;
                base[cnt++] = temp;
            }
        }
    }

    ll query_k(ll k) {
        k -= flag;
        if(k == 0) return 0;
        if(k >= 1ll << cnt) return -1;
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if(k >> i & 1) {
                ans ^= base[i];
            }
        }
        return ans;
    }
    void init() {
        memset(base, 0, sizeof base), flag = cnt = 0;
    }
}a;

const int N = 1e5 + 10;

int head[N], to[N], nex[N], cnt = 1, n, m;

ll value[N], dis[N];

bool vis[N];

void add(int x, int y, ll w) {
  to[cnt] = y;
  nex[cnt] = head[x];
  value[cnt] = w;
  head[x] = cnt++;
}

void dfs(int rt, int fa, ll w) {
  vis[rt] = 1, dis[rt] = w;
  for (int i = head[rt]; i; i = nex[i]) {
    if (to[i] == fa) {
      continue;
    }
    if (vis[to[i]]) {
      a.add(w ^ dis[to[i]] ^ value[i]);
    }
    else {
      dfs(to[i], rt, w ^ value[i]);
    }
  }
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= m; i++) {
    int x, y;
    ll w;
    scanf("%d %d %lld", &x, &y, &w);
    add(x, y, w);
  }
  dfs(1, 0, 0);
  printf("%lld\n", a.query_max(dis[n]));
  return 0;
}

P3292 [SCOI2016]幸运数字

用线段树来维护区间线性基并，最后用树剖来进行查询操作。

#include <bits/stdc++.h>
#define mid (l + r >> 1)
#define lson rt << 1, l, mid
#define rson rt << 1 | 1, mid + 1, r
#define ls rt << 1
#define rs rt << 1 | 1

using namespace std;

typedef long long ll;

const int N = 2e4 + 10;

int head[N], to[N << 1], nex[N << 1], cnt = 1;

int son[N], fa[N], sz[N], dep[N], top[N], id[N], rk[N], tot;

int n, m;

ll value[N], tree[N << 2][64], ans[64];

void add(int x, int y) {
  to[cnt] = y;
  nex[cnt] = head[x];
  head[x] = cnt++;
}

void dfs1(int rt, int f) {
  dep[rt] = dep[f] + 1;
  sz[rt] = 1, fa[rt] = f;
  for(int i = head[rt]; i; i = nex[i]) {
    if(to[i] == f) continue;
    dfs1(to[i], rt);
    if(!son[rt] || sz[son[rt]] < sz[to[i]]) son[rt] = to[i];
    sz[rt] += sz[to[i]];
  }
}

void dfs2(int rt, int tp) {
  top[rt] = tp; tot++;
  rk[tot] = rt, id[rt] = tot;
  if(!son[rt]) return ;
  dfs2(son[rt], tp);
  for(int i = head[rt]; i; i = nex[i]) {
    if(to[i] == fa[rt] || to[i] == son[rt]) continue;
    dfs2(to[i], to[i]);
  }
}

void insert(ll * base, ll x) {
  for(int i = 60; i >= 0; i--) {
    if(x >> i & 1) {
      if(!base[i]) {
        base[i] = x;
        return ;
      }
      x ^= base[i];
    }
  }
}

void merge(ll * a, ll * b) {
  for(int i = 60; i >= 0; i--) {
    if(b[i]) {
        insert(a, b[i]);
    }
  }
}

void push_up(int rt) {
  merge(tree[rt], tree[ls]);
  merge(tree[rt], tree[rs]);
}

void build(int rt, int l, int r) {
  if(l == r) {
    insert(tree[rt], value[rk[l]]);
    return ;
  }
  build(lson);
  build(rson);
  push_up(rt);
}

void query(int rt, int l, int r, int L, int R) {
  if(l >= L && r <= R) {
    merge(ans, tree[rt]);
    return ;
  }
  if(L <= mid) query(lson, L, R);
  if(R > mid)  query(rson, L, R);
}

ll query_max() {
  ll res = 0;
  for(int i = 60; i >= 0; i--) {
    if((res ^ ans[i]) > res) {
      res ^= ans[i];
    }
    ans[i] = 0;
  }
  return res;
}

ll solve(int x, int y) {
  while(top[x] != top[y]) {
    if(dep[top[x]] < dep[top[y]]) swap(x, y);
    query(1, 1, n, id[top[x]], id[x]);
    x = fa[top[x]];
  }
  if(dep[x] > dep[y]) swap(x, y);
  query(1, 1, n, id[x], id[y]);
  return query_max();
}

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  scanf("%d %d", &n, &m);
  for(int i = 1; i <= n; i++) {
    scanf("%lld", &value[i]);
  }
  for(int i = 1; i < n; i++) {
    int x, y;
    scanf("%d %d", &x, &y);
    add(x, y);
    add(y, x);
  }
  dfs1(1, 0);
  dfs2(1, 1);
  build(1, 1, n);
  for(int i = 1; i <= m; i++) {
    int x, y;
    scanf("%d %d", &x, &y);
    printf("%lld\n", solve(x, y));
  }
	return 0;
}

[CQOI2013] 新Nim游戏

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct linearbasis {
    ll base[64], flag, cnt;

    bool add(ll x) {
        for(int i = 62; ~i; i--) {
            if(x >> i & 1) {
                if(!base[i]) {
                    base[i] = x;
                    return false;
                }
                x ^= base[i];
            }
        }
        flag = 1;
        return true;
    }

    ll query_max(ll ans = 0) {
        for(int i = 62; ~i; i--) {
            if((ans ^ base[i]) > ans) {
                ans ^= base[i];
            }
        }
        return ans;
    }

    ll query_min() {
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                return base[i];
            }
        }
    }

    void rebuild() {
        cnt = 0;
        for(int i = 62; i >= 0; i--) {
            for(int j = i - 1; j >= 0; j--) {
                if(base[i] >> j & 1) {
                    base[i] ^= base[j];
                }
            }
        }
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                ll temp = base[i];
                base[i] = 0;
                base[cnt++] = temp;
            }
        }
    }

    ll query_k(ll k) {
        k -= flag;
        if(k == 0) return 0;
        if(k >= 1ll << cnt) return -1;
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if(k >> i & 1) {
                ans ^= base[i];
            }
        }
        return ans;
    }
    void init() {
        memset(base, 0, sizeof base), flag = cnt = 0;
    }
}a;

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n;
  scanf("%d", &n);
  vector<int> ans(n);
  for (int i = 0; i < n; i++) {
    scanf("%d", &ans[i]);
  }
  sort(ans.begin(), ans.end(), greater<int> ());
  ll res = 0;
  for (int i = 0; i < n; i++) {
    if (a.add(ans[i])) {
      res += ans[i];
    }
  }
  printf("%lld\n", res);
  return 0;
}

[BJWC2011]元素

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct linearbasis {
    ll base[64], flag, cnt;

    bool add(ll x) {
        for(int i = 62; ~i; i--) {
            if(x >> i & 1) {
                if(!base[i]) {
                    base[i] = x;
                    return false;
                }
                x ^= base[i];
            }
        }
        flag = 1;
        return true;
    }

    ll query_max(ll ans = 0) {
        for(int i = 62; ~i; i--) {
            if((ans ^ base[i]) > ans) {
                ans ^= base[i];
            }
        }
        return ans;
    }

    ll query_min() {
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                return base[i];
            }
        }
    }

    void rebuild() {
        cnt = 0;
        for(int i = 62; i >= 0; i--) {
            for(int j = i - 1; j >= 0; j--) {
                if(base[i] >> j & 1) {
                    base[i] ^= base[j];
                }
            }
        }
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                ll temp = base[i];
                base[i] = 0;
                base[cnt++] = temp;
            }
        }
    }

    ll query_k(ll k) {
        k -= flag;
        if(k == 0) return 0;
        if(k >= 1ll << cnt) return -1;
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if(k >> i & 1) {
                ans ^= base[i];
            }
        }
        return ans;
    }
    void init() {
        memset(base, 0, sizeof base), flag = cnt = 0;
    }
}a;

const int N = 1e3 + 10;

struct Res {
  ll id, value;

  void read() {
    scanf("%lld %lld", &id, &value);
  }

  bool operator < (const Res &t) const {
    return value > t.value;
  }

}b[N];

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n;
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    b[i].read();
  }
  sort (b + 1, b + 1 + n);
  ll ans = 0;
  for (int i = 1; i <= n; i++) {
    if (a.add(b[i].id)) {
      continue;
    }
    ans += b[i].value;
  }
  printf("%lld\n", ans);
  return 0;
}

Square Subsets

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

struct linearbasis {
    ll base[64], flag, cnt;

    bool add(ll x) {
        for(int i = 62; ~i; i--) {
            if(x >> i & 1) {
                if(!base[i]) {
                    base[i] = x;
                    return false;
                }
                x ^= base[i];
            }
        }
        flag = 1;
        return true;
    }

    ll query_max(ll ans = 0) {
        for(int i = 62; ~i; i--) {
            if((ans ^ base[i]) > ans) {
                ans ^= base[i];
            }
        }
        return ans;
    }

    ll query_min() {
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                return base[i];
            }
        }
    }

    void rebuild() {
        cnt = 0;
        for(int i = 62; i >= 0; i--) {
            for(int j = i - 1; j >= 0; j--) {
                if(base[i] >> j & 1) {
                    base[i] ^= base[j];
                }
            }
        }
        for(int i = 0; i <= 62; i++) {
            if(base[i]) {
                ll temp = base[i];
                base[i] = 0;
                base[cnt++] = temp;
            }
        }
    }

    ll query_k(ll k) {
        k -= flag;
        if(k == 0) return 0;
        if(k >= 1ll << cnt) return -1;
        ll ans = 0;
        for(int i = 62; ~i; i--) {
            if(k >> i & 1) {
                ans ^= base[i];
            }
        }
        return ans;
    }
    void init() {
        memset(base, 0, sizeof base), flag = cnt = 0;
    }
}a;

int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67};

const int mod = 1e9 + 7;

int main() {
  // freopen("in.txt", "r", stdin);
  // freopen("out.txt", "w", stdout);
  // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int n, ans = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    int x, value = 0;
    cin >> x;
    for (int j = 0; j < 19; j++) {
      int cnt = 0;
      while (x % prime[j] == 0) {
        cnt++;
        x /= prime[j];
      }
      if (cnt & 1) {
        value |= 1 << j;
      }
    }
    if (a.add(value)) {
      ans++;
    }
  }
  ll res = 1;
  for (int i = 1; i <= ans; i++) {
    res = res * 2 % mod;
  }
  printf("%lld\n", res - 1);
  return 0;
}
_lifehappy_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
显式非线性专题.pdf
05-20
显式非线性专题.pdf
20200228 专题：线性基
hongkongreporter
02-29 85
咕~~~
彩灯（线性基）
UniverseofHK的博客
09-25 132
彩灯 线性基基础题（1ll<<i1ll<<i1ll<<i一定要写llllll !） 单纯地想在线性基专题中水一篇博客，hhh 题意：没啥讲的 思路：太简单了（求线性空间的秩） 题面描述 #include "bits/stdc++.h" #define hhh printf("hhh\n") #define see(x) (cerr<<(#x)<...
（ 数论专题 ）【 线性基 】
石旭先森的博客
02-28 469
（ 数论专题 ）【 线性基 】 线性基是啥？ 线性基是竞赛中常用来解决子集异或一类题目的算法，具体看下面例题。 线性基是一个数的集合，并且每个序列都拥有至少一个线性基，取线性基中若干个数异或起来可以得到原序列中的任何一个数。 复习知识点：《 线性代数 》里的行阶梯矩阵。 上面是行阶梯矩阵的化简步骤，最后行秩为3，那这个有什么用呢，我们可以通过化简后的这...
线性基学习笔记
denghu0527的博客
07-31 78
线性基专题学习 (仅以此篇表愚见) 引入：最大异或和 (笔者希望你在看这个之前学过了高斯消元) 我们先把线性基放到一边，如何用高斯消元解决呢? （下面的陈述可能有些问题，某些细节和实现希望读者自己想一下） ---->从高到低确定每一位是否能选，即设这一位方程的右边为1，解当前的方程组判断是否有解，一共是解60次方程组\(O(n \cdot 60^3)\) ---->优化：保...
数学/数论专题-学习笔记：线性基
Plozia 的小窝
07-01 246
线性基学习笔记。注意是 OI 中的不是数学中的。
线性基 学习笔记
skyline的分享专栏
08-22 79
学习视频：时光蒸汽喵带你做专题-线性基 #include<bits/stdc++.h> using namespace std; using ll = long long; const int maxn=5e5+5;//原来的数 const int maxbit=63; ll A[maxn];//原来的数 ll P[maxbit];// P[j] 第j位为最高位1的数 最高位1在第...
2019 Multi-University Training Contest 1：Operation（贪心 + 线性基）
qq_41997978的博客
07-22 101
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6579 题目大意：给一个初始长度为n的序列，有两种操作： 0 l r：询问[l,r]最大子集异或和 1 x：将x加在序列尾部，使得序列边成一个长度为n + 1的新序列 （看到子集异或和就想到了线性基，但数据范围太大，如果用线段树暴力维护区间线性基，复杂度会达到O(n∗log3n)O(n * log^3...
数学/数论专题-专项训练2：线性基
Plozia 的小窝
07-16 130
数学/数论专题-专项训练：线性基1. 前言2. 练习题[P4301 [CQOI2013] 新Nim游戏](https://www.luogu.com.cn/problem/P4301)[P4151 [WC2011]最大XOR和路径](https://www.luogu.com.cn/problem/P4151)[P5556 圣剑护符](https://www.luogu.com.cn/problem/P5556)3. 总结 1. 前言 本篇博文是作者学习线性基时候的一些专项训练。 因为作者是个 OIer，本
数学/数论专题-专项训练1：线性基
Plozia 的小窝
07-01 146
数学/数论专题-专项训练：线性基1. 前言2. 练习题[P4570 [BJWC2011]元素](https://www.luogu.com.cn/problem/P4570)[P3857 [TJOI2008]彩灯](https://www.luogu.com.cn/problem/P3857)[P3292 [SCOI2016]幸运数字](https://www.luogu.com.cn/problem/P3292)3. 总结 1. 前言 本篇博文是作者学习线性基的专项训练。 数学/数论专题-学习笔记：线性
线性回归基本原理1
08-03
引入，则有此时模型中的参数是一个维的向量，任何一个训练实例也是一个维的向量，特征矩阵的维度是因此公式整体可以转化为矩阵形式2. 梯度下降线性回归的目标函数为所以
线性代数- 线性基与前缀线性基.rar
09-16
线性代数- 线性基与前缀线性基.rar
线性代数知识点和题型：换基公式
12-25
原创的一篇文章，讲述线性代数中的换基公式 这是线性空间这一章的重要公式，对于作线性变换具有重要意义
拉格朗日法线性规划求解
12-21
拉格朗日法线性规划求解 目录拉格朗日法线性规划求解1、拉格朗日乘子法2、拉格朗日乘子法例题求解直接计算python中scipy包实现 1、拉格朗日乘子法 拉格朗日乘数法（以数学家约瑟夫·路易斯·拉格朗日命名）是一种...
setuptools-58.0.3.tar.gz
05-12
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
变压器DGA溶解气体数据（357组）
最新发布
05-13
包含六种故障类型： 中低温过热 高温过热 低能放电 高能放电 局部放电 正常 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111需要直接下载就可
电抗器设计软件.zip
05-12
电抗器设计软件
base.apk
05-12
base.apk
线性基判断原集合封闭
08-16
线性基可以用来判断原集合是否封闭。如果一个元素能够被线性基的基向量线性表示，那么它就可以由原集合中的元素经过线性组合得到，即原集合是封闭的。否则，如果有一个元素不能被线性基的基向量线性表示，那么它就...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值