线性基小结

于 2021-07-23 14:09:34 发布
阅读量118 收藏
点赞数
分类专栏： ACM--数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49959202/article/details/119032903
版权
本文介绍了线性基的概念和算法分析，包括线性基的性质、构建模板以及在不同问题中的应用。线性基是解决异或相关问题的有效工具，如在元素选择、游戏策略和路径优化等场景下发挥作用。
摘要由CSDN通过智能技术生成

文章目录

线性基

1.算法分析

线性基的本质是用一个数x的尽可能高位的1来代表x
    线性基是向量空间的一组基，通常可以解决有关异或的一些题目。
    通俗一点的讲法就是由一个集合构造出来的另一个集合，它有以下几个性质：

  1. 线性基的元素能相互异或得到原集合的元素的所有相互异或得到的值。
  2. 线性基是满足性质 1 的最小的集合。
  3. 线性基没有异或和为 0 的子集。
  4. 线性基中每个元素的异或方案唯一，也就是说，线性基中不同的异或组合异或出的数都是不一样的。
  5. 线性基中每个元素的二进制最高位互不相同

2.模板

#include<bits/stdc++.h>
 
using namespace std;
 
typedef long long LL;
 
struct Linear_Basis{
 
    LL d[61],p[61];  // d记录原先的，p记录重构后的
    int cnt, flag;  // cnt记录重构后有多少个，flag记录是否出现过0
 
    Linear_Basis() {
        memset(d, 0 ,sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;  // 当前线性基内元素个数
        flag = 0;  // 不存在0
    }
 
    // 构造线性基:逐个元素插入
    bool insert(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    return true;  // 插入成功
                }
                val ^= d[i];
            }
        }
        flag = 1;  // 存在0
        return false; // 插入失败
    }
 
    // 查询第最大异或和
    LL query_max() {
        LL ret = 0;
        for (int i = 60; i >= 0; i--)
            if ((ret ^ d[i]) > ret)
                ret ^= d[i];
        return ret;
    }
 
    // 查询最小异或和
    LL query_min() {
        for (int i = 0;i <= 60; i++)
            if (d[i])
                return d[i];
        return 0;
    }
 
    // 重构，使之形成对角矩阵
    void rebuild() {
        for (int i = 60;i >= 0; i--)  // 当前i位时，把后面的j位情况都和i位情况做异或
            for (int j = i - 1;j >= 0; j--)
                if (d[i] & (1ll << j))
                    d[i] ^= d[j];
        for (int i = 0; i <= 60; i++)  // 记录重构结果
            if (d[i])
                p[cnt++] = d[i];
    }
 
    // 查询第k小
    LL kthquery(LL k){
        LL ret = 0;
        if (flag) {  // 存在0
            k--;
            if (!k) return (LL)0;
        }
        if (k >= (1ll << cnt))  // 只能由2^cnt - 1个
            return -1;
        for (int i = 60; i >= 0; i--)
            if (k & (1LL << i))  // 每位的贡献为2^i
                ret ^= p[i];
        return ret;
    }
};
 
// 合并线性基
Linear_Basis merge(const Linear_Basis &n1, const Linear_Basis &n2) {
    Linear_Basis ret = n1;
    for (int i = 60; i >= 0; i--)
        if (n2.d[i])
            ret.insert(n2.d[i]);
    return ret;
}
 
int main(){
 
    int n;
    scanf("%d",&n);
    Linear_Basis lb;
    for(int i=0;i<n;i++){
        LL a;
        scanf("%lld",&a);
        lb.insert(a);
    }
    printf("%lld\n",lb.query_max());
    return 0;
}

3.例题

P4570 [BJWC2011]元素
题意： 给n个整数，每个整数带一个权值v，求一个权值和最大的线性基。
题解： 按权值v从大->小排序，依次插入线性基。要是能够插入，那么累加到答案
代码：

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

int const N = 1e3 + 10;
struct MAGIC {
    LL val, magic;
    bool operator<(const MAGIC &t) const {
        return magic > t.magic;
    }
}magic[N];
 
struct Linear_Basis{
 
    LL d[61],p[61];
    int cnt, flag = 0;
 
    Linear_Basis(){
        memset(d, 0, sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;
        flag = 0;
    }
 
    // 构造线性基:逐个元素插入
    bool ins(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    break;
                }
                val ^= d[i];
            }
        }
        return val > 0; // 返回1说明插入成功；返回0插入失败，说明出现异或和为0的情况
    }
};
 
int main(){
 
    int n;
    scanf("%d",&n);
    Linear_Basis lb;
    LL sum = 0;
    for(int i=0;i<n;i++){
        LL t1, ma;
        cin >> t1 >> ma;
        magic[i].val = t1, magic[i].magic = ma;
    }
    sort(magic, magic + n);
    for (int i = 0; i < n; ++i) {
        if (lb.ins(magic[i].val)) sum += magic[i].magic;
    }
    printf("%lld\n", sum);
    return 0;
}

acwing229 新nim游戏
题意： 第1和2回合，可以拿走任意堆，但不能全拿，从第3回合后开始和普通nim游戏一样。问第1回合拿走多少堆才能必胜。如果能必胜，输出拿走的石子数目；如果不能，输出-1.
题解： 要使必胜，那么第1回合拿完后，其余剩余石子无论怎么异或都不会出现0，那么把石子从大到小排序，逐个往线性基内插入。如果插入不了，说明出现0，必须拿走。
代码：

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

int const N = 1e3 + 10;
LL a[N];
 
struct Linear_Basis{
 
    LL d[61],p[61];
    int cnt, flag;
 
    Linear_Basis(){
        memset(d, 0, sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;
        flag = 0;
    }
 
    // 构造线性基:逐个元素插入
    bool ins(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    break;
                }
                val ^= d[i];
            }
        }
        return val > 0; // 返回1说明插入成功；返回0插入失败，说明出现异或和为0的情况
    }
};
 
int main(){
 
    int n;
    scanf("%d",&n);
    Linear_Basis lb;
    LL sum = 0;
    for(int i=0;i<n;i++){
        cin >> a[i];
    }
    sort(a, a + n);
    reverse(a, a + n);
    for (int i = 0; i < n; ++i) {
        if (!lb.ins(a[i])) sum += a[i];
    }
    if (!sum) sum = -1;
    printf("%lld\n", sum);
    return 0;
}

acwing210异或运算
题意： 求第k小异或和
题解： 板题
代码：

#include<bits/stdc++.h>
 
using namespace std;
 
typedef long long LL;
int const N = 1e4 + 10;
int t, n, m, kase;
LL a[N];
 
struct Linear_Basis{
 
    LL d[61],p[61];
    int cnt, flag;
 
    Linear_Basis() {
        memset(d, 0 ,sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;  // 当前线性基内元素个数
        flag = 0;  // 不存在0
    }
 
    // 构造线性基:逐个元素插入
    bool insert(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    return true;  // 插入成功
                }
                val ^= d[i];
            }
        }
        flag = 1;  // 存在0
        return false; // 插入失败
    }
 
    // 重构，使之形成对角矩阵
    void rebuild() {
        for (int i = 60;i >= 0; i--)  // 当前i位时，把后面的j位情况都和i位情况做异或
            for (int j = i - 1;j >= 0; j--)
                if (d[i] & (1ll << j))
                    d[i] ^= d[j];
        for (int i = 0; i <= 60; i++)  // 记录重构结果
            if (d[i])
                p[cnt++] = d[i];
    }
 
    // 查询第k小
    LL kthquery(LL k){
        LL ret = 0;
        if (flag) {  // 存在0
            k--;
            if (!k) return (LL)0;
        }
        if (k >= (1ll << cnt))  // 只能由2^cnt - 1个
            return -1;
        for (int i = 60; i >= 0; i--)
            if (k & (1LL << i))  // 每位的贡献为2^i
                ret ^= p[i];
        return ret;
    }
 
};
 
int main(){
    cin >> t;
    while (t--) {
        printf("Case #%d:\n", ++kase);
        cin >> n;
        Linear_Basis lb;
        for (int i = 1; i <= n; ++i) {
            cin >> a[i];
            lb.insert(a[i]);
        }
        lb.rebuild();
        
        cin >> m;
        for (int i = 1; i <= m; ++i) {
            LL t;
            cin >> t;
            cout << lb.kthquery(t) << endl;
        }
    }
    return 0;
}

acwing228异或
题意： 给一个无向连通图，求一条从1到n的路径（可以不是简单路径），使经过的边权的异或和最大。
题解： 本题要求最大XOR路径，可以分析出来最大只要是个环，那么都可以经过。因此只需要找到一条1~n的路径，而后不断把环的权值异或，看是否能变大即可。分析一下找环，如果不是一个简单环，那么一定可以由简单环异或得到，因此只要找简单环即可。找简单环只要dfs判断环的思路即可
代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
int const N = 5e4 + 10, M = 1e5 + 10;
int e[M * 2], ne[M * 2], h[N], idx, st[N];
LL w[M * 2], a[N];
int n, m;

struct Linear_Basis{
 
    LL d[61],p[61];
    int cnt, flag;
 
    Linear_Basis() {
        memset(d, 0 ,sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;  // 当前线性基内元素个数
        flag = 0;  // 不存在0
    }
 
    // 构造线性基:逐个元素插入
    bool insert(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    return true;  // 插入成功
                }
                val ^= d[i];
            }
        }
        flag = 1;  // 存在0
        return false; // 插入失败
    }
 
    // 查询第最大异或和
    LL query_max(LL x) {
        LL ret = x;
        for (int i = 60; i >= 0; i--)
            if ((ret ^ d[i]) > ret)
                ret ^= d[i];
        return ret;
    }
}lb;

void add(int a, int b, LL c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
 
// 找简单环
void dfs(int u, int fa) {
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == fa) continue;
        
        if (st[j]) {
            lb.insert(a[u] ^ a[j] ^ w[i]);  // 找到环，插入线性基
        }
        else {  // 否则，更新
            a[j] = a[u] ^ w[i];  
            dfs (j, u);
        }
    }
}

int main() {
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 1, a, b; i <= m; ++i) {
        LL d;
        scanf("%d %d %lld", &a, &b, &d);
        add(a, b, d), add(b, a, d);
    }
    
    dfs (1, -1);
    cout << lb.query_max(a[n]) << endl;  // 找到1~n的路径，然后线性基找最大值
    return 0;
}

luogu P3857 [TJOI2008]彩灯
题意： 一组彩灯是由一排 N 个独立的灯泡构成的，并且有 M 个开关控制它们。问有多少种样式可以展示？有m行，每行给定n个字符，如：OX。如果第 i 个字母是大写字母 O，则表示这个开关控制第 i 盏灯，如果第 i 个字母是大写字母 X，则表示这个开关不控制此灯。N,M~50
题解： 灯泡开关就是0和1，选和不选，就是判断对角矩阵线性基选和不选。因此重构之后变成对角矩阵后，里面有x个基底，那么就要2^x种情况。这就等价于给定n个数，求n个数的子集的异或值有多少种
代码：

#include<bits/stdc++.h>
 
using namespace std;
 
typedef long long LL;
int const MOD = 2008;
int n, m;
 
struct Linear_Basis{
 
    LL d[61],p[61];
    int cnt, flag;
 
    Linear_Basis() {
        memset(d, 0 ,sizeof(d));
        memset(p, 0, sizeof(p));
        cnt = 0;  // 当前线性基内元素个数
        flag = 0;  // 不存在0
    }
 
    // 构造线性基:逐个元素插入
    bool insert(LL val) {
        for (int i = 60;i >= 0; i--) {
            if (val & (1ll << i)) {  // 判断当前i位能否插入
                if (!d[i]) {  // 如果当前i位没插入过元素
                    d[i] = val;  // 插入
                    return true;  // 插入成功
                }
                val ^= d[i];
            }
        }
        flag = 1;  // 存在0
        return false; // 插入失败
    }
 
    // 重构，使之形成对角矩阵
    void rebuild() {
        for (int i = 60;i >= 0; i--)  // 当前i位时，把后面的j位情况都和i位情况做异或
            for (int j = i - 1;j >= 0; j--)
                if (d[i] & (1ll << j))
                    d[i] ^= d[j];
        for (int i = 0; i <= 60; i++)  // 记录重构结果
            if (d[i])
                p[cnt++] = d[i];
    }
}lb;

int main(){
    cin >> n >> m;
    for (int i = 1; i <= m; ++i) {
        LL all = 0;
        for (int j = n - 1; j >= 0; --j) {
            char op;
            cin >> op;
            if (op == 'O') all += (1ll << j);
        }
        lb.insert(all);
    }
    lb.rebuild();
    cout << min(((1ll << lb.cnt)), (1ll << n)) % MOD;
    return 0;
}

acwing209装备购买
题意： 游戏有n件装备，每件装备有m个属性，如果第i件装备可以被其他任意件装备乘上对应系数表示出来，那么第i件装备不需要花钱购买，否则需要花钱。求最多可以购买多少件装备，同时求出在最多件装备的情况下的最小花费。
装备数N ~ 500,属性数M ~ 500
题解： 借鉴线性基和高斯消元的方法，每次插入一个数字，就把它拿之前的元素消元，直到把当前元素消成当前位不存在的情况。如果当前数组不断消元最后为0，那么这个数字可以被其他数组表示。如果当前数组消到第i位时，不存在这样的数组，那么这个数组可以插入线性基内，这个数组不可以被其他数组表示
需要花钱购买该装备。为了这个花费最小，需要贪心从小到大排序
代码：

#include <bits/stdc++.h>

using namespace std;

int const N = 510;
double const eps = 1e-5;
int n, m;
double a[N][N];  // a表示线性基，第i个线性基的第j个元素为a[i][j]
struct COST {
    double z[N], cost;
    
    bool operator< (struct COST &t) const {
        return cost < t.cost;
    }
}cost[N];

// 插入线性基
bool insert(double x[]) {
    for (int i = 1; i <= m; ++i) {
        if (fabs(x[i]) < eps) continue;  // 当前x为0，那么不需要插入 
        if (fabs(a[i][i]) > eps) {  // 如果第i个线性基存在，那么需要对x进行消除操作，把第x[i]变成0
            double div = x[i] / a[i][i];  
            for (int j = i; j <= m; ++j) {  // 修改x数组
                x[j] -= div * a[i][j];
            }
        }
        else {  // 如果第i个线性基不存在
            for (int j = i; j <= m; ++j) a[i][j] = x[j];  // 插入到线性基内
            return true;
        }
    }
    return false;
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            cin >> cost[i].z[j];
        }
    }
    
    for (int i = 1; i <= n; ++i) cin >> cost[i].cost;
    sort(cost + 1, cost + n + 1);
    
    // 不断插入线性基，如果能够插入，说明需要花费；否则，不需要花费
    double res1 = 0, res2 = 0;
    for (int i = 1; i <= n; ++i) {
        if (insert(cost[i].z)) {
            res1 ++;
            res2 += cost[i].cost;
        }
    }
    cout << res1 << " " << res2;
    return 0;
}
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习小结】线性基
执子之手,与子偕老
05-10 154
menci的讲解 发现了线性基的一些性质和用法 线性基合并 直接把另一个暴力插入。 可以判一下如果满了就不插入，剪枝很有作用 一定要满足从高位到低位贪心 struct Data{ int a[32]; bool flag; Data(){ memset(a,0,sizeof(a)); flag = 0; } Data operator + (Data z){ Data res =...
线性基
繁凡さん的博客
07-13 535
ACM模板 线性基是一种擅长处理异或问题的数据结构.设值域为[1,N][1,N][1,N]，就可以用一个长度为⌈log⁡2N⌉\lceil \log_2N \rceil⌈log2​N⌉的数组来描述一个线性基。特别地，线性基第i位上的数二进制下最高位也为第i位。 一个线性基满足，对于它所表示的所有数的集合S，S中任意多个数异或所得的结果均能表示为线性基中的元素互相异或的结果，即意，线性基能使用异或运算来表示原数集使用异或运算能表示的所有数。运用这个性质，我们可以极大地缩小异或操作所需的查询次数。 本模板支持
线性基学习
ENESAMA的博客
12-03 119
今天随手看了一看线性基，感觉似乎不太难 当然我也没有看懂证明，可能就只是因为异或后的组合值域与原来组合的值域相同 所以随便搞一下，进行处理就可以了(雾 建议康康 ljh2000 dalao的博客，似乎讲的很清楚 还有运用方法的总结。 代码更是奇短无比 for(int i=1;i&lt;=n;i++) { for(int j=62;j&gt;=0;j--) { if(!(...
线性基学习笔记
Kumii
11-27 250
线性基学习笔记
hdu3949
weixin_30628801的博客
07-27 120
XOR Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1648Accepted Submission(s): 503 Problem Description XOR is a kind of bit operator, we...
线性筛法
m0_49959202的博客
09-19 2808
文章目录线性筛法1. 算法分析1.1 线性筛求素数1.2 线性筛求欧拉函数1.3 线性筛求莫比乌斯函数1.4 线性筛求约数个数1.5 线性筛求约束和2. 模板2.1 线性筛求素数2.2 线性筛求欧拉函数2.3 线性筛求莫比乌斯函数2.4 线性筛求约数个数2.5 线性筛求约数和 线性筛法 1. 算法分析 关键思想：每个数字都被它的最小质因数筛掉 1.1 线性筛求素数 i % pj = 0i\ \%\ p_j \ =\ 0i % pj​&nbsp
曼哈顿距离与切比雪夫距离及其相互转化
m0_49959202的博客
07-23 1569
文章目录曼哈顿距离与切比雪夫距离及其相互转化1.算法分析1.1 曼哈顿距离1.2 切比雪夫距离1.3 两者之间的关系1.4 用处2.典型例题 曼哈顿距离与切比雪夫距离及其相互转化 1.算法分析 1.1 曼哈顿距离 定义 设平面空间内存在两点，它们的坐标为(x1,y1)，(x2,y2)(x_1,y_1)，(x_2,y_2)(x1​,y1​)，(x2​,y2​) 则dis=∣x1−x2∣+∣y1−y2∣dis=|x_1−x_2|+|y_1−y_2|dis=∣x1​−x2​∣+∣y1​−y2​∣ 即两点横纵坐标差
置换群
m0_49959202的博客
09-20 1019
文章目录置换群1.1 算法分析1.1.1 群1.1.1.1 群的定义1.1.1.2 子群1.1.1.3 置换1.1.2 轨道与稳定化子定理1.1.3 Burnside 引理与polay定理1.1.3.1 Burnside 引理1.1.3.2 polay定理1.2 典型例题 置换群 1.1 算法分析 置换群通常用来解决一些涉及“本质不同”的计数问题，例如用 3 种颜色给一个立方体染色，求本质不同的方案数（经过翻转后相同的两种方案视为同一种）。 1.1.1 群 1.1.1.1 群的定义 若集合 S≠∅S \n
同余式
m0_49959202的博客
09-19 778
文章目录同余式1. 算法分析1.1 同余式常用定理1.1.1 欧拉公式/费马小定理1.1.2 威尔逊公式1.1.3 扩展欧几里得1.2 乘法逆元1.3 求解同余式1.3.1 求解一次同余式1.3.2 求解高次同余式1.4 中国剩余定理1.5 思维同余性质2.板子2.1 同余式常用定理2.2 乘法逆元2.3 求解同余式2.4 中国剩余定理3. 例题3.1 同余式常用定理3.2 求解同余式3.3 中国剩余定理3.4 思维同余性质 同余式 1. 算法分析 1.1 同余式常用定理 1.1.1 欧拉公式/费马小定理
特殊数列小结
m0_49959202的博客
07-23 675
文章目录特殊数列1.算法分析1.1 哈代-拉马努金拆分数列1.2 斐波那契数列1.2.1 数列描述1.2.2 性质1.2.2.1 求和公式1.2.2.2 gcd性质1.2.2.3 隔项性质1.2.2.4 整除性质1.2.2.5 其他性质1.2.3 斐波那契编码1.2.4 斐波那契数列通项公式1.2.4.1 解析解1.2.4.2 矩阵形式1.2.4.3 快速倍增法2.模板2.1 哈代-拉马努金拆分数列2.2 斐波那契数列3.典型例题 特殊数列 1.算法分析 1.1 哈代-拉马努金拆分数列 数列： 1, 1,
互质与欧拉函数
m0_49959202的博客
09-19 654
文章目录互质与欧拉函数1. 算法分析2. 板子3. 例题 互质与欧拉函数 1. 算法分析 基本概念 欧拉函数：1~N中与N互质的数的个数 在算术基本定理中:N = (p1a1) * (p2a2) * … *(pmam) 一个数的欧拉函数: φ(N)=N * (1-1/p1) * (1-1/p2) * … * (1-1/pm) 且φ(1) = φ(2) = 1 重要结论 1~N中，(x, y) = 1的对数为: 前1~N的欧拉函数的前缀和 * 2 - 1 常用思路 很多求gcd(x, y)=p的问题，最后都需
多项式小结
m0_49959202的博客
07-23 571
多项式 文章目录多项式一 简介二 拉格朗日插值2.1 知识点2.2 模板2.1 随机给定n个点插值：O(n2logn)O(n^2log_n)O(n2logn​)2.2 给定连续n个点插值:O(n)O(n)O(n)2.3 例题三 快速傅里叶变换3.1 知识点3.2 模板3.3 例题四 快速数论变换4.1 知识点4.2 模板五 多项式求逆六 多项式开方七 多项式除法|取模八 多项式对数函数|指数函数九 牛顿迭代法十 多项式三角函数十二 多项式反三角函数 一 简介 **多项式的度：**对于一个多项式f(x)f(x
质数与约数
m0_49959202的博客
09-20 504
文章目录质数与约数1. 算法分析1.1 基本概念1.2 常用公式和性质1.2.1 质数1.2.2 约数2. 板子2.1 质数2.1.1 素数判定2.1.2 质因数分解2.1.3 筛素数2.2 约数2.2.1 求x相关2.2.2 求1~N相关2.1.3 gcd3. 例题 质数与约数 1. 算法分析 1.1 基本概念 质数: 作为最小单位，无法再进行拆分 约数: 8的约数有1，2，4，8 1.2 常用公式和性质 1.2.1 质数 重要结论 int范围内最多只有10个不重复质因子，且所有质数的次数总和不能超过3
拉格朗日插值法
m0_49959202的博客
02-18 503
文章目录拉格朗日插值法1.算法分析2.模板2.1 随机给定n个点插值：O(n2logn)O(n^2log_n)O(n2logn​)2.2 给定连续n个点插值:O(n)O(n)O(n)3.典型例题 拉格朗日插值法 1.算法分析 给定nnn个点P(xi,yi)P(x_i, y_i)P(xi​,yi​), 将过这nnn个点的最多n−1n - 1n−1次多项式记为f(X)f(X)f(X)，求f(k)f(k)f(k)， 答案模上998244353998244353998244353返回。 拉格朗日插值的公式f(x)
组合计数2-隔板法
m0_49959202的博客
06-24 497
文章目录组合计数2-隔板法1.算法分析1.1 隔板法定义1.2 普通隔板法1.3 添元素隔板法1.4 选板法1.5 分类插板1.6 逐步插板2.典型例题 组合计数2-隔板法 1.算法分析 博客参考：https://blog.csdn.net/sdz20172133/article/details/81431066?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162452359116780264076722%2522%252C%2522scm
组合计数
m0_49959202的博客
09-20 471
文章目录组合计数1. 算法分析1.1 组合数/排列数1.2 错排数1.3 卡特兰数2. 板子2.1 a、b小(a、b~1e4)，模数大2.2 a、b大(a、b~1e8)，模数大2.3 a、b大(a、b~1e18)，模数小2.4 a、b大(a、b~1e7)，模数没有3. 例题3.1 组合数/排列数/乘法原理/加法原理3.2 错排数3.3 卡特兰数 组合计数 1. 算法分析 1.1 组合数/排列数 C[a][b]:从a里面选b个的方案 递推：C[a][b] = C[a-1][b]+C[a-1][b-1] 可以
中位数
m0_49959202的博客
02-20 469
文章目录中位数1.算法分析1.1 求数组的中位数1.1.1 sort求中位数1.1.2 二分求中位数1.2 中位数性质2.典型例题2.1 动态维护中位数2.2 二分求中位数2.3 绝对值不等式--中位数性质 中位数 1.算法分析 1.1 求数组的中位数 1.1.1 sort求中位数 sort。直接sort排序，然后中位数就是a[n / 2]，这样的时间复杂度为O(nlogn)O(nlog_n)O(nlogn​) 1.1.2 二分求中位数 二分。二分当前中位数为mid，然后O(n)O(n)O(n)扫一遍数组，
韦达定理小结
m0_49959202的博客
07-23 395
韦达定理 文章目录韦达定理韦达定理1.算法分析2.模板3.典型例题 韦达定理 1.算法分析 韦达定理： []( 2.模板 //从低到高递推求系数，x为零点坐标 void _Get_xi() { b[1] = 1; for (int i = 1; i <= cnt; i++) { for (int j = i + 1; j >= 1; j--) { b[j] = b[j - 1]; } for (int j
积性函数&数论分块&迪利克雷卷积&杜教筛&莫比乌斯函数及其反演
m0_49959202的博客
09-19 369
文章目录积性函数&数论分块&迪利克雷卷积&杜教筛&莫比乌斯函数及其反演1. 算法分析1.1 积性函数1.1.1 定义1.1.2 常见积性函数1.1.3 常见完全积性函数1.2 迪利克雷卷积1.3 数论分块1.4 杜教筛1.5 莫比乌斯反演1.6 数论公式推导套路小结2. 板子2.1 数论分块(整除分块)2.1.1 一维分块2.1.2 二维分块2.2 筛法求莫比乌斯函数3. 典型例题3.1 数论分块3.2 杜教筛3.3 莫比乌斯函数 积性函数&数论分块&迪利克雷
矩阵乘法
m0_49959202的博客
09-19 317
文章目录矩阵乘法1. 算法分析2. 板子3. 例题3.1 直接处理矩阵运算3.2 斐波那契数列+矩阵快速幂 矩阵乘法 1. 算法分析 利用快速幂的方法来优化矩阵的乘法，使得计算矩阵A(N*N)的M次方的时间优化到O(N3logM) 常用技巧 一般如果能够把式子写成 Kn = Kn-1+t，那就能使用矩阵快速幂处理，设Fn=[fn, fn+1, kn], Fn+1=[fn+1, fn+2, kn+1],那么Fn+1=FnA (A为矩阵) 2. 板子 计算ax #include <bits/stdc+
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值