【矩阵快速幂 | 斐波那契数列 | 矩阵加速】

news2024/11/25 16:10:10

在这里插入图片描述

文章目录

    • 基础知识
      • 1. 矩阵结构
      • 2. 重载 * 运算符
      • 3. 矩阵快速幂
    • 例题1： 矩阵幂求和
    • 例题2： 矩阵快速幂
    • 例题3： 斐波那契数列
    • 例题4： 矩阵加速
    • 例题5： 广义斐波那契
    • 例题6： 斐波那契公约数
    • 例题7： 这个勇者明明超强却过分慎重

基础知识

1. 矩阵结构

struct Matrix {
    int g[N][N];
        // 矩阵初始化。type 为 true 则初始化为 E，type 为 false 则初始化为 O。
    void init(bool type) {
        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= n; j++) 
                if(i != j) g[i][j] = 0;
                else g[i][j] = type == true ? 1 : 0;
    }
};

2. 重载 * 运算符

Matrix operator*(const Matrix &o) const {
    Matrix t;
    t.init(false); // 0 矩阵
    for (int i = 1; i <= n; i++) // 三重循环
        for (int j = 1; j <= n; j++) 
            for (int k = 1; k <= n; k++)
                t.g[i][j] = (t.g[i][j] + o.g[i][k] * g[k][j]) % mod;
    return t;
}

3. 矩阵快速幂

// 计算a^k
Matrix operator^(Matrix a, int k) { // 重载矩阵快速幂
    Matrix res;
    res.init(true); 
    while (k) {
        if (k & 1) res = res * a;
        a = a * a;
        k >>= 1;
    }
    return res;
}

例题1： 矩阵幂求和

矩阵幂求和

S = A + A 2 + A 3 + . . . + A k S=A+A^2+A^3+...+A^k \\\\ S=A+A2+A3+...+Ak

  • 推导如下：

1. 当 k 为偶数：

S = A + . . . + A k / 2 + A k / 2 + 1 + . . . + A k = A + . . . + A k / 2 + A k / 2 ∗ ( A + . . . + A k / 2 ) = ( A k / 2 + E ) ∗ S k / 2 \begin{align} S&=A+...+A^{k/2}+A^{k/2+1}+...+A^k\\ &=A+...+A^{k/2}+A^{k/2}*(A+...+A^{k/2}) \\ &=(A^{k/2}+E)*S_{k/2} \end{align} S​=A+...+Ak/2+Ak/2+1+...+Ak=A+...+Ak/2+Ak/2∗(A+...+Ak/2)=(Ak/2+E)∗Sk/2​​​

2. 当 k 为奇数

令  k = 2 ∗ n + 1 ,     2 ∗ n = k − 1 令 \ k = 2*n+1, \ \ \ 2*n = k - 1 \\ 令 k=2∗n+1,   2∗n=k−1
S = A + A 2 + A 3 + . . . + A 2 n + 1 = A + A ∗ ( A + . . . + A 2 n ) = A + A ∗ S 2 n = A + A ∗ S k − 1 \begin{align} S&=A+A^2+A^3+...+A^{2n+1} \\ &=A+A*(A+...+A^{2n}) \\ &=A + A*S_{2n}\\ &=A+A*S_{k-1} \end{align} S​=A+A2+A3+...+A2n+1=A+A∗(A+...+A2n)=A+A∗S2n​=A+A∗Sk−1​​​

代码如下：

#include <iostream>
using namespace std;
// https://www.acwing.com/solution/content/15850/
typedef long long ll;
const int N = 110;
int n, mod, k;
// const int mod = 1e9 + 7;

struct Matrix {
    int g[N][N];

    // 矩阵初始化。type 为 true 则初始化为 E，type 为 false 则初始化为 O。
    void init(bool type) {
        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= n; j++) 
                if(i != j) g[i][j] = 0;                 // 两种矩阵的共同点：不在 i = j 对角线上的数皆为 0
                else g[i][j] = type == true ? 1 : 0;    // 不同点：在 i = j 对角线上，E 为 1，O 为 0
    }

    Matrix operator*(const Matrix &o) const {
        Matrix t;
        t.init(false);
        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= n; j++) 
                for (int k = 1; k <= n; k++)
                    t.g[i][j] = (t.g[i][j] + o.g[i][k] * g[k][j]) % mod;
        return t;
    }

    Matrix operator+(const Matrix &o) const // 重载矩阵加法
    {
        Matrix t;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                t.g[i][j] = (g[i][j] + o.g[i][j]) % mod;
        return t;
    }

    void print() {  // 将该矩阵输出
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++)
                printf("%d ", g[i][j]);
            puts("");
        }
    }

    void read() { // 读入该矩阵
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++) {
                scanf("%d", &g[i][j]);
                g[i][j] %= mod;
            }
    }

};

// 计算a^k
Matrix operator^(Matrix a, int k) { // 重载矩阵快速幂。由于要用到乘法，所以在结构体外重载。
    Matrix res;
    res.init(true); 
    while (k) {
        if (k & 1) res = res * a;
        a = a * a;
        k >>= 1;
    }
    return res;
}

Matrix E, v; // E 即 E 矩阵，v 为读入矩阵

// 计算S=A+A**2+A**3+...+A**k
Matrix S(int k) {
    if (k == 1) return v;                  // 如果 k 为 1，那么返回 v，终止递归。
    if (k & 1) return v + v * S(k - 1);    // 如果 k 是奇数，那么返回上述 A + A * S(k - 1)
    return (E + (v ^ k >> 1)) * S(k >> 1); // 否则返回上述 (E + A ^ (k / 2)) * S(k / 2)
}

int main() {
    cin >> n >> k >> mod; 			// scanf
    E.init(true);   // 初始化矩阵E
    v.read();       // 读入矩阵v
    S(k).print();   // 计算S(k)并输出
    return 0;
}

例题2： 矩阵快速幂

矩阵快速幂

  • 框架如上题，PS： long long
	scanf("%lld %lld", &n, &k);
    E.init(true);
    v.read();
    (v^k).print();

例题3： 斐波那契数列

f n = { 1 , ( n < = 2 ) f n − 1 + f n − 2 , ( n > = 3 ) f_n=\begin{cases} 1, & (n<=2) \\ f_{n-1} + f_{n-2}, & (n>=3)\\ \end{cases} fn​={1,fn−1​+fn−2​,​(n<=2)(n>=3)​

  • 分析如下：

通过递推式，推出 1 × 2   ∗ 2 × 2 = = 1 × 2 的方阵（ 2 × 2 ） f n = f n − 1 ∗ 1 + f n − 2 ∗ 1 f n − 1 = f n − 1 ∗ 1 + f n − 2 ∗ 0 推出（ 2 × 2 ）矩阵： ∣ 1 1 1 0 ∣ 通过递推式， 推出 1 × 2 \ * 2 × 2 == 1 × 2 的方阵（2×2）\\ \begin{align} f_n &= f_{n-1} * 1 + f_{n-2}* 1 \\ f_{n-1}&=f_{n-1}*1+f_{n-2}* 0 \\ \end{align} \\ 推出（2×2）矩阵： \begin{vmatrix} \mathbf{1} & \mathbf{1} \\ \mathbf{1} & \mathbf{0} \\ \end{vmatrix} \\ 通过递推式，推出1×2 ∗2×2==1×2的方阵（2×2）fn​fn−1​​=fn−1​∗1+fn−2​∗1=fn−1​∗1+fn−2​∗0​​推出（2×2）矩阵： ​11​10​ ​
最终结果： [ f n   f n − 1 ] = ∣ 1 1 1 0 ∣ n − 1 ∗ [ f 1   f 0 ] 最终结果： [f_n \ f_{n-1}] = \begin{vmatrix} \mathbf{1} & \mathbf{1} \\ \mathbf{1} & \mathbf{0} \\ \end{vmatrix} ^{n-1} * [f_1 \ f_0] 最终结果：[fn​ fn−1​]= ​11​10​ ​n−1∗[f1​ f0​]

#include <iostream>
#include <cstring>
using namespace std;

typedef long long ll;
const int mod = 1e9 + 7;
const int N = 3;

struct Matrix {
    ll g[N][N];
};

Matrix E, v; // E是单位阵（也是最终答案矩阵（快速幂））， v是推导出的初始的2×2 矩阵

void init() {
    memset(E.g, 0, sizeof(E));
    for (int i = 1; i <= 2; i++) E.g[i][i] = 1;
    memset(v.g, 0, sizeof(v.g));
    v.g[1][1] = v.g[1][2] = v.g[2][1] = 1;
}

Matrix mul(Matrix a, Matrix b) {
    Matrix t;
    memset(t.g, 0, sizeof(t));
    for (int i = 1; i <= 2; i++) 
        for (int j = 1; j <= 2; j++)
            for (int k = 1; k <= 2; k++)
                t.g[i][j] = (t.g[i][j] + a.g[i][k] * b.g[k][j]) % mod;
    return t;
}

void qmi(ll k) {
    while(k) {
        if(k & 1) E = mul(E, v);
        v = mul(v, v);
        k >>= 1;
    }
}

void print(Matrix a) {
    for (int i = 1; i <= 2; i++) {
        for (int j = 1; j <= 2; j++)
            cout << a.g[i][j] << " ";
        cout << endl;
    }
}

int main() {
    ll n; cin >> n;
    init();
    qmi(n - 1);
    cout << E.g[1][1] << endl;
    return 0;
}

例题4： 矩阵加速

矩阵加速

#include <iostream>
#include <cstring>
using namespace std;

typedef long long ll;

const int mod = 1e9 + 7;
const int N = 4;
int T, n;

struct Matrix {
    ll g[N][N];
};

Matrix E, v;

void init() {
    memset(E.g, 0, sizeof(E.g));
    for (int i = 1; i <= 3; i++) E.g[i][i] = 1;
    memset(v.g, 0, sizeof(v.g));
    v.g[1][1] = v.g[1][3] = v.g[2][1] = v.g[3][2] = 1;
}

Matrix mul(Matrix a, Matrix b) {
    Matrix t;
    memset(t.g, 0, sizeof(t.g));
    for (int i = 1; i <= 3; i++) 
        for (int j = 1; j <= 3; j++)
            for (int k = 1; k <= 3; k++)
                t.g[i][j] = (t.g[i][j] + a.g[i][k] * b.g[k][j]) % mod;
    return t;
}

void qmi(int k) {
    init();
    while(k) {
        if(k & 1) E = mul(E, v);
        v = mul(v, v);
        k >>= 1;
    }
}

void print(Matrix a) {
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++)
            cout << a.g[i][j] << " ";
        cout << endl;
    }
}

int main() {
    cin >> T;
    while(T--) {
        cin >> n;
        if(n <= 3) {
            cout << 1 << endl;
            continue;
        }
        qmi(n);
        cout << E.g[2][1] << endl;
    }
    return 0;
}

例题5： 广义斐波那契

广义斐波那契

广义斐波那契数列是指形如： a n = p × a N − 1 + q × a n − 2  的数列 广义斐波那契数列是指形如：a_n = p × a_{N-1} + q × a_{n-2} \ 的数列 广义斐波那契数列是指形如：an​=p×aN−1​+q×an−2​ 的数列

  • 推导如下：

目标矩阵： [ F n   F n − 1 ] ⬇ F n = p × F n − 1 + q × F n − 2 ⬇ [ F n − 1   F N − 2 ] × ∣ p 1 q 0 ∣ ⬇ [ ( p × F n − 1 + q × F n − 2 )   ( F n − 1 × 1 + F N − 2 × 0 ) ] ⬇ [ F n   F n − 1 ] 目标矩阵： [F_n \ F_{n-1}] \\ ⬇ \\ F_n=p×F_{n-1}+q×F_{n-2} \\ ⬇ \\ [F_{n-1} \ F_{N-2}] × \begin{vmatrix} p & 1 \\ q & 0 \\ \end{vmatrix} \\ ⬇ \\ [(p×F_{n-1}+q×F_{n-2}) \ (F_{n-1} × 1 + F_{N-2} ×0)] \\ ⬇ \\ [F_{n} \ F_{n-1}] 目标矩阵：[Fn​ Fn−1​]⬇Fn​=p×Fn−1​+q×Fn−2​⬇[Fn−1​ FN−2​]× ​pq​10​ ​⬇[(p×Fn−1​+q×Fn−2​) (Fn−1​×1+FN−2​×0)]⬇[Fn​ Fn−1​]

void init() {
    memset(E.g, 0, sizeof(E.g));
    E.g[1][1] = a2, E.g[1][2] = a1;
    memset(v.g, 0, sizeof(v.g));
    v.g[1][1] = p;
    v.g[1][2] = 1;
    v.g[2][1] = q;
}

例题6： 斐波那契公约数

斐波那契公约数

  • 结论： g c d ( F n ,   F m ) = F ( g c d ( n ,   m ) ) gcd(F_n, \ F_m) = F(gcd(n, \ m)) gcd(Fn​, Fm​)=F(gcd(n, m))
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;
const int mod = 1e8;
const int N = 3;

struct Matrix {
    ll g[N][N];
};

Matrix E, v; // E是单位阵（也是最终答案矩阵（快速幂））， v是推导出的初始的2×2 矩阵

void init() {
    memset(E.g, 0, sizeof(E));
    for (int i = 1; i <= 2; i++) E.g[i][i] = 1;
    memset(v.g, 0, sizeof(v.g));
    v.g[1][1] = v.g[1][2] = v.g[2][1] = 1;
}

Matrix mul(Matrix a, Matrix b) {
    Matrix t;
    memset(t.g, 0, sizeof(t));
    for (int i = 1; i <= 2; i++) 
        for (int j = 1; j <= 2; j++)
            for (int k = 1; k <= 2; k++)
                t.g[i][j] = (t.g[i][j] + a.g[i][k] * b.g[k][j]) % mod;
    return t;
}

void qmi(ll k) {
    init();
    while(k) {
        if(k & 1) E = mul(E, v);
        v = mul(v, v);
        k >>= 1;
    }
}

void print(Matrix a) {
    for (int i = 1; i <= 2; i++) {
        for (int j = 1; j <= 2; j++)
            cout << a.g[i][j] << " ";
        cout << endl;
    }
}

int main() {
    int n, m; cin >> n >> m;
    n = __gcd(n, m);
    if(n <= 2) {
        cout << 1 << endl;
        return 0;
    }
    qmi(n - 1);
    // print(E);
    cout << E.g[1][1] << endl;
    return 0;
}

例题7： 这个勇者明明超强却过分慎重

这个勇者明明超强却过分慎重

#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
#define js ios::sync_with_stdio(false);cin.tie(0); cout.tie(0)
typedef long long ll;
inline ll read() { ll s = 0, w = 1; char ch = getchar(); while (ch < 48 || ch > 57) { if (ch == '-') w = -1; ch = getchar(); }    while (ch >= 48 && ch <= 57) s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();    return s * w; }

const int mod = 666666;
const int N = 2; //矩阵规模
const int M = 2;

struct Node {
    ll matrix[N][M];//结构体中的矩阵
    Node() {//默认构造函数
        memset(matrix, 0, sizeof(matrix));
    }
    void one() {//单位矩阵
        for (int i = 0; i < N; ++i)
            matrix[i][i] = 1;
    }
    Node operator*(Node other) {//矩阵运算重载*运算符
        Node ans;//记录乘积
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++)
                for (int k = 0; k < N; k++) {
                    ans.matrix[i][j] += matrix[i][k] * other.matrix[k][j];
                    ans.matrix[i][j] %= mod;
                }
        return ans;
    }
};
Node power(Node a, ll b) {//快速幂求a的b次方
    Node res;
    res.one();//单位矩阵
    while (b) {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}
int main() {
    Node st, p;
    // [f[1], f[2]] = [4, 233];
    st.matrix[0][0] = 4;
    st.matrix[0][1] = 233;
   	// f(n) = 4 * f(n - 1) + 3 * f(n - 2)
    // 0 3
    // 1 4
    p.matrix[0][1] = 3;
    p.matrix[1][0] = 1;
    p.matrix[1][1] = 4;
    int n, m;
    while(~scanf("%d %d", &n, &m))
        printf("%d\n", m - (st * power(p, n - 1)).matrix[0][0]);
    return 0;
}

ps: 矩阵拓展

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/473150.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

设计模式——设计模式介绍和单例设计模式

设计模式——设计模式介绍和单例设计模式

目录 一、设计模式概述和分类 1.1 设计模式介绍 1.2 设计模式分类 二、创建型设计模式-单例模式 2.1 介绍 2.2 八种单例模式的创建方式 2.2.1 饿汉式&#xff08;静态常量&#xff09; 2.2.2 饿汉式&#xff08;静态代码块&#xff09; 2.2.3 懒汉式&#xff08;线程…
阅读更多...
TCP/IP协议基础

TCP/IP协议基础

1.TCP/IP模型的分层 网络接口层&#xff08;Network Interface Layer&#xff09;&#xff1a;&#xff08;数据链路层&#xff09; 功能&#xff1a; ①将数据帧发送到物理网络&#xff0c;并从物理网络接收数据帧。 ②处理硬件地址&#xff0c;如MAC地址。 主要协议&#xff…
阅读更多...
[独家]自动播放K线图训练盘感能力！股票量化分析工具QTYX-V2.3.5

[独家]自动播放K线图训练盘感能力！股票量化分析工具QTYX-V2.3.5

K线量价的重要性 K线图对炒股的朋友来说太熟悉不过了&#xff0c;每一根K线包含了开盘价、收盘价、最高价和最低价这四个价位信息&#xff0c;分别用红和绿两种颜色来表示上涨或下跌&#xff0c;反映了单位时间周期内价格变动的情况。 不过K线的功效可不仅仅用来记录价格的变动…
阅读更多...
Linux信号：信号 信号集 信号集函数

Linux信号：信号 信号集 信号集函数

1. 信号的概念 Linux进程间通信的方式之一。信号也称为“软件中断”。 信号特点&#xff1a; 简单&#xff1b;携带信息有限&#xff1b;满足特定条件才发送信号&#xff1b;可进行用户空间和内核空间进程的交互&#xff1b; 信号4要素&#xff1a; &#xff08;1&#xf…
阅读更多...
根据Java的TreeMap源码的原理编写C++红黑树删除操作

根据Java的TreeMap源码的原理编写C++红黑树删除操作

&#xff08;一&#xff09;了解二叉搜索树的删除操作 删除操作总结&#xff1a; ******普通结点删除&#xff1a;******* ①删除叶结点 ②删除只有1个子结点的结点 >>如果被删除结点的左子树为空&#xff0c;则令其右子树子承父业代替其位置即可 >>如果被删除结点…
阅读更多...
JPA整合达梦数据库

JPA整合达梦数据库

陈老老老板&#x1f9b8; &#x1f468;‍&#x1f4bb;本文专栏&#xff1a;国产数据库-达梦数据库&#xff08;主要讲一些达梦数据库相关的内容&#xff09; &#x1f468;‍&#x1f4bb;本文简述&#xff1a;本文讲一下SpringBoot整合JPA与达梦数据库&#xff0c;就是简单&…
阅读更多...
《算法工程师带你去》读书笔记

《算法工程师带你去》读书笔记

什么是稀疏向量&#xff08;向量的稀疏表示&#xff09; 对数据进行预处理时&#xff0c;一般需要对类别型特征进行编码&#xff1a; 序号编码独热编码 二进制编码 其中独热编码用的是最多的。但是当类别数十分巨大时&#xff0c;独热编码是一个非常稀疏的向量&#xff0c;只有…
阅读更多...
IDEA（八）常用插件推荐

IDEA（八）常用插件推荐

目录 1.GitHub Copilot2.MyBatisCodeHelperPro3.Maven Helper4.Translation5.Api Savior6.Alibaba Java Coding Guidelines7.Sequence Diagram8.Key Promoter X9.Restfultoolkit-fix 在IDEA中&#xff0c;Ctrl Alt S 选择 Plugins&#xff0c;可以添加很多帮助我们开发的插件…
阅读更多...
Arduino串口提取数字（整型和浮点型）

Arduino串口提取数字（整型和浮点型）

数据提取 文章目录 数据提取前言一、提取整型数据二、提取浮点型数据 前言 之前需要用32和ESP进行通信上传数据&#xff0c;一直都用的都是数据上传然后处理成整型数据&#xff0c;今天需要处理成浮点型数据所以就查了一下&#xff0c;于是就记录一下。 一、提取整型数据 #i…
阅读更多...
〖Python网络爬虫实战⑳〗- 数据存储之CSV操作实战

〖Python网络爬虫实战⑳〗- 数据存储之CSV操作实战

订阅&#xff1a;新手可以订阅我的其他专栏。免费阶段订阅量1000 python项目实战 Python编程基础教程系列&#xff08;零基础小白搬砖逆袭) 说明&#xff1a;本专栏持续更新中&#xff0c;目前专栏免费订阅&#xff0c;在转为付费专栏前订阅本专栏的&#xff0c;可以免费订阅付…
阅读更多...
JDBC数据库连接技术学习笔记

JDBC数据库连接技术学习笔记

1. 概述 本笔记是学习尚硅谷教育的23版jdbc的课后笔记 1.1 JDBC概念和理解 1. jdbc是(Java Database Connectivity)单词的缩写,翻译为java连接数据库 2. jdbc是java程序连接数据库的技术统称 3. jdbc由java语言的规范(接口)和各个数据库厂商的实现驱动(jar)组成 4. jdbc是一…
阅读更多...
Mysql 判断语句

Mysql 判断语句

目录 5 判读 5.1 if ... then ...->示例演示 局部变量 -> 打包储存过程 5.2 case 5.2.1 语法一 5.2.2 语法二 -> 示例演示 5.3 while 循环 ->有条件循环 5.3.1 示例演示 5.4 repeat 循环 -> 满足条件 -> 退出循环 5.4.1 示例演示 5.5 loop 5.5.1…
阅读更多...
【c语言小项目】基于easyX的俄罗斯方块

【c语言小项目】基于easyX的俄罗斯方块

EeayX是针对 C/C 的简单图形库插件&#xff0c;本项目基于easyX游戏框架下实现俄罗斯方块游戏。 俄罗斯方块功能实现中主要运用了二维数组的循环遍历。能够实现基本功能&#xff0c;暂未实现旋转 c语言系列专栏&#xff1a;c语言之路重点知识整合 更多相关&#xff1a;c语…
阅读更多...
AI VS 好莱坞？新时代电影工作流；MJ制作微信表情包的麻瓜教程；关于ControlNet的一切；AI创业真钱景 | ShowMeAI日报

AI VS 好莱坞？新时代电影工作流；MJ制作微信表情包的麻瓜教程；关于ControlNet的一切；AI创业真钱景 | ShowMeAI日报

&#x1f440;日报&周刊合集 | &#x1f3a1;生产力工具与行业应用大全 | &#x1f9e1; 点赞关注评论拜托啦&#xff01; &#x1f916; 『OpenAI通过了一大批GPT-4申请』大量放号ing~快去看邮箱&#xff01; &#x1f916; 『小马智行 | 广州南沙区开启车内无安全员的自动…
阅读更多...
opencv-python加载pytorch训练好的onnx格式线性回归模型

opencv-python加载pytorch训练好的onnx格式线性回归模型

opencv是一个开源的图形库&#xff0c;有针对java,c,python的库依赖&#xff0c;它本身对模型训练支持的不好&#xff0c;但是可以加载其他框架训练的模型来进行预测。 这里举一个最简单的线性回归的例子&#xff0c;使用深度学习框架pytorch训练模型&#xff0c;最后保存模型为…
阅读更多...
【软考备战·希赛网每日一练】2023年4月28日

【软考备战·希赛网每日一练】2023年4月28日

文章目录 一、今日成绩二、错题总结第一题第二题第三题 三、知识查缺 题目及解析来源&#xff1a;2023年04月28日软件设计师每日一练 一、今日成绩 二、错题总结 第一题 解析&#xff1a; 大体了解即可&#xff0c;题目要考察的核心意思&#xff1a;确定的有限自动机和不确定的…
阅读更多...
js 操作数组内容

js 操作数组内容

js 操作数组内容 数组添加元素&#xff08;更改原数组&#xff09; push和unshift会返回添加了新元素的数组长度 push从数组最后加入&#xff0c;unshift从数组最前面加入 const arr ["a", "b", "c"]; arr.push("d"); //返回4…
阅读更多...
数据结构基础day9

数据结构基础day9

题目&#xff1a;187. 重复的DNA序列 解法1&#xff1a;哈希表 class Solution { public:vector<string> findRepeatedDnaSequences(string s) {vector<string> ans;unordered_map<string, int> mp;int ns.size(), L10;for(int i0; i<n-L; i){ //从开头…
阅读更多...
【fluent UDF】warning: unused variable警报：存在未使用的变量

【fluent UDF】warning: unused variable警报：存在未使用的变量

一、问题背景 在编译UDF时&#xff0c;出现如下错误 curing_heat_v3.c: In function ‘iter_ending’: curing_heat_v3.c:105:14: warning: unused variable ‘volume_sum’ [-Wunused-variable] real volume_sum0.0; curing_heat_v3.c:104:14: warning: unused variable ‘…
阅读更多...
【Python零基础学习入门篇②】——第二节：Python的常用语句

【Python零基础学习入门篇②】——第二节：Python的常用语句

⬇️⬇️⬇️⬇️⬇️⬇️ ⭐⭐⭐Hello&#xff0c;大家好呀我是陈童学哦&#xff0c;一个普通大一在校生&#xff0c;请大家多多关照呀嘿嘿&#x1f601;&#x1f60a;&#x1f618; &#x1f31f;&#x1f31f;&#x1f31f;技术这条路固然很艰辛&#xff0c;但既已选择&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023