第四章 数学知识

news2024/11/19 8:44:51

第四章 数学知识

初等数论二：https://www.acwing.com/blog/content/26394/

质数

试除法判定质数

bool is_prime(int x)
{
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
}

试除法分解质因数

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;  // 大于sqrt(n)的质因数
    cout << endl;
}

朴素筛法求素数

// O(nlogn)
// 不论质数和合数均去除i的2 3 4 …倍的数字
int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if(!st[i]) primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)  // 筛掉i的倍数
            st[j] = true;
    }
}

埃氏筛法求素数

// O(nloglogn)
// 只去除质数的倍数
int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if(!st[i]){
            primes[cnt ++ ] = i;
            for (int j = i + i; j <= n; j += i)  // 筛掉i的倍数
                st[j] = true;
        }      
    }
}

线性筛法求素数

// O(n)
// 每个合数只会被自己的 最小质因子 筛去
int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )  // 将i乘以素数序列中的每一个数筛掉
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;  // 当primes[j]为i的最小质因子时
        }
    }
}

约数

试除法求所有约数

vector<int> get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

约数个数和约数之和

// 如果 N = p1^c1 * p2^c2 * ... *pk^ck
// 约数个数： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
// 约数之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)

#include <iostream>
#include <unordered_map>

using namespace std;

const int mod = 1e9 + 7;

typedef long long LL;

unordered_map<int, int> primes;

void get_primes(int x){
    for(int i = 2; i <= x / i; i ++)
        while(x % i == 0){
            x /= i;
            primes[i] ++;
        }
    if(x > 1) primes[x] ++;
}

int main(){
    int n, x;
    cin >> n;
    
    while(n --){
        cin >> x;
        get_primes(x);
    }
    
    LL res = 1;	
    
    // 求个数
    for(auto prime : primes) res = res * (prime.second + 1) % mod;
    
    // 求和
    for(auto prime : primes){
        int p = prime.first, a = prime.second;
        LL t = 1;
        while(a --) t = (t * p + 1) % mod;
        res = res * t % mod;
    }
    
    cout << res << endl;
    
    return 0;
}

欧几里得算法（辗转相除法）

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

欧拉函数

在这里插入图片描述
互质：最大公约数为1，即gcd(a, b) = 1

求欧拉函数

int phi(int x)
{
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res = res / i * (i - 1);  // 先除后乘，否则溢出
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);

    return res;
}

筛法求欧拉函数

int primes[N], cnt;     // primes[]存储所有素数
int euler[N];           // 存储每个数的欧拉函数
bool st[N];         // st[x]存储x是否被筛掉

void get_eulers(int n)
{
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)
            {
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

快速幂

快速幂

求 a^k mod p，时间复杂度 O(logk)。

int qmi(int a, int k, int p)
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

快速幂求逆元

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;


LL qmi(int a, int b, int p)
{
    LL res = 1;
    while (b)
    {
        if (b & 1) res = res * a % p;
        a = a * (LL)a % p;
        b >>= 1;
    }
    return res;
}


int main()
{
    int n;
    scanf("%d", &n);
    while (n -- )
    {
        int a, p;
        scanf("%d%d", &a, &p);
        if (a % p == 0) puts("impossible");
        else printf("%lld\n", qmi(a, p - 2, p));
    }

    return 0;
}

扩展欧几里得算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VmC9oNwY-1684724736370)(C:\Users\yuemi\AppData\Roaming\Typora\typora-user-images\image-20230419204929610.png)]

// 求x, y，使得ax + by = gcd(a, b)
int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

中国剩余定理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y0OWQHzu-1684724736370)(C:\Users\yuemi\AppData\Roaming\Typora\typora-user-images\image-20230422195758343.png)]

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;


LL exgcd(LL a, LL b, LL &x, LL &y)
{
    if (!b)
    {
        x = 1, y = 0;
        return a;
    }

    LL d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}


int main()
{
    int n;
    cin >> n;

    LL x = 0, m1, a1;
    cin >> m1 >> a1;
    for (int i = 0; i < n - 1; i ++ )
    {
        LL m2, a2;
        cin >> m2 >> a2;
        LL k1, k2;
        LL d = exgcd(m1, m2, k1, k2);
        if ((a2 - a1) % d)
        {
            x = -1;
            break;
        }

        k1 *= (a2 - a1) / d;
        k1 = (k1 % (m2/d) + m2/d) % (m2/d);

        x = k1 * m1 + a1;

        LL m = abs(m1 / d * m2);
        a1 = k1 * m1 + a1;
        m1 = m;
    }

    if (x != -1) x = (a1 % m1 + m1) % m1;

    cout << x << endl;

    return 0;
}

高斯消元

// a[N][N]是增广矩阵
int gauss()
{
    int c, r;
    for (c = 0, r = 0; c < n; c ++ )
    {
        int t = r;
        for (int i = r; i < n; i ++ )   // 找到绝对值最大的行
            if (fabs(a[i][c]) > fabs(a[t][c]))
                t = i;

        if (fabs(a[t][c]) < eps) continue;

        for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 将绝对值最大的行换到最顶端
        for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 将当前行的首位变成1
        for (int i = r + 1; i < n; i ++ )       // 用当前行将下面所有的列消成0
            if (fabs(a[i][c]) > eps)
                for (int j = n; j >= c; j -- )
                    a[i][j] -= a[r][j] * a[i][c];

        r ++ ;
    }

    if (r < n)
    {
        for (int i = r; i < n; i ++ )
            if (fabs(a[i][n]) > eps)
                return 2; // 无解
        return 1; // 有无穷多组解
    }

    for (int i = n - 1; i >= 0; i -- )
        for (int j = i + 1; j < n; j ++ )
            a[i][n] -= a[i][j] * a[j][n];

    return 0; // 有唯一解
}

求组合数

递推法求组合数

O(N^2)

// c[a][b] 表示从a个苹果中选b个的方案数
for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

通过预处理逆元的方式求组合数

O(NlogN)

首先预处理出所有阶乘取模的余数fact[N]，以及所有阶乘取模的逆元infact[N]
如果取模的数是质数，可以用费马小定理求逆元

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 100010, mod = 1e9 + 7;

int fact[N], infact[N];

int qmi(int a, int k, int p)    // 快速幂模板
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

int main()
{
    
    // 预处理阶乘的余数和阶乘逆元的余数
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i ++ )
    {
        fact[i] = (LL)fact[i - 1] * i % mod;
        infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
    }

    int n;
    scanf("%d", &n);
    while (n -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", (LL)fact[a] * infact[b] % mod * infact[a - b] % mod);
    }

    return 0;
}

Lucas 定理

若p是质数，则对于任意整数 1 <= m <= n，有：
    C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)

int qmi(int a, int k){
    int res = 1;
    while(k){
        if(k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

int C(int a, int b){  // 定理求C(a, b)
    int res = 1;
    for(int i = 1, j = a; i <= b; i ++, j --){
        res = (LL)res * j % p;
        res = (LL)res * qmi(i, p - 2) % p;
    }
    return res;
}

int lucas(LL a, LL b){
    if(a < p && b < p) return C(a, b);
    return (LL)C(a % p, b % p) * lucas(a / p, b / p) % p;
}

分解质因数法求组合数

当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
    1. 筛法求出范围内的所有质数
    2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n!中p的次数是 n / p + n / p^2 + n / p^3 + ...
    3. 用高精度乘法将所有质因子相乘

int primes[N], cnt;     // 存储所有质数
int sum[N];     // 存储每个质数的次数
bool st[N];     // 存储每个数是否已被筛掉


void get_primes(int n)      // 线性筛法求素数
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}


int get(int n, int p)       // 求n!中的次数
{
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
}


vector<int> mul(vector<int> &A, int b)    // 高精度乘低精度模板
{    
    vector<int> C;
    int t = 0;
    for(int i = 0; i < A.size() || t; i ++){
        if(i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
    return C;
}


get_primes(a);  // 预处理范围内的所有质数

for (int i = 0; i < cnt; i ++ )     // 求每个质因数的次数
{
    int p = primes[i];
    sum[i] = get(a, p) - get(b, p) - get(a - b, p);
}

vector<int> res;
res.push_back(1);

for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
    for (int j = 0; j < sum[i]; j ++ )
        res = mul(res, primes[i]);

卡特兰数

给定n个0和n个1，它们按照某种顺序排成长度为2n的序列，满足任意前缀中0的个数都不少于1的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)

// 满足条件的01序列

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010, mod = 1e9 + 7;


int qmi(int a, int k, int p)
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}


int main()
{
    int n;
    cin >> n;

    int a = n * 2, b = n;
    int res = 1;
    for (int i = a; i > a - b; i -- ) res = (LL)res * i % mod;
    for (int i = 1; i <= b; i ++ ) res = (LL)res * qmi(i, mod - 2, mod) % mod;

    res = (LL)res * qmi(n + 1, mod - 2, mod) % mod;

    cout << res << endl;

    return 0;
}

容斥原理

2^20 = 106，1秒计算107-10^8次

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 20;

int p[N];


int main()
{
    int n, m;
    cin >> n >> m;

    for (int i = 0; i < m; i ++ ) cin >> p[i];

    int res = 0;
    for (int i = 1; i < 1 << m; i ++ )
    {
        int t = 1, s = 0;
        for (int j = 0; j < m; j ++ )
            if (i >> j & 1)
            {
                if ((LL)t * p[j] > n)
                {
                    t = -1;
                    break;
                }
                t *= p[j];
                s ++ ;
            }

        if (t != -1)
        {
            if (s % 2) res += n / t;
            else res -= n / t;
        }
    }

    cout << res << endl;

    return 0;
}

博弈论

Nim 游戏

给定N堆物品，第i堆物品有Ai个。两名玩家轮流行动，每次可以任选一堆，取走任意多个物品，可把一堆取光，但不能不取。取走最后一件物品者获胜。两人都采取最优策略，问先手是否必胜。

我们把这种游戏称为NIM博弈。把游戏过程中面临的状态称为局面。整局游戏第一个行动的称为先手，第二个行动的称为后手。若在某一局面下无论采取何种行动，都会输掉游戏，则称该局面必败。
所谓采取最优策略是指，若在某一局面下存在某种行动，使得行动后对面面临必败局面，则优先采取该行动。同时，这样的局面被称为必胜。我们讨论的博弈问题一般都只考虑理想情况，即两人均无失误，都采取最优策略行动时游戏的结果。
NIM博弈不存在平局，只有先手必胜和先手必败两种情况。

定理： NIM博弈先手必胜，当且仅当 A1 ^ A2 ^ … ^ An != 0

公平组合游戏ICG

若一个游戏满足：

由两名玩家交替行动；
在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关；
不能行动的玩家判负；
则称该游戏为一个公平组合游戏。
NIM博弈属于公平组合游戏，但城建的棋类游戏，比如围棋，就不是公平组合游戏。因为围棋交战双方分别只能落黑子和白子，胜负判定也比较复杂，不满足条件2和条件3。

有向图游戏

给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。
任何一个公平组合游戏都可以转化为有向图游戏。具体方法是，把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。

Mex运算

设S表示一个非负整数集合。定义mex(S)为求出不属于集合S的最小非负整数的运算，即：mex(S) = min{x}, x属于自然数，且x不属于S

SG函数

在有向图游戏中，对于每个节点x，设从x出发共有k条有向边，分别到达节点y1, y2, …, yk，定义SG(x)为x的后继节点y1, y2, …, yk 的SG函数值构成的集合再执行mex(S)运算的结果，即：SG(x) = mex({SG(y1), SG(y2), …, SG(yk)})。特别地，整个有向图游戏G的SG函数值被定义为有向图游戏起点s的SG函数值，即SG(G) = SG(s)。

有向图游戏的和

设G1, G2, …, Gm 是m个有向图游戏。定义有向图游戏G，它的行动规则是任选某个有向图游戏Gi，并在Gi上行动一步。G被称为有向图游戏G1, G2, …, Gm的和。有向图游戏的和的SG函数值等于它包含的各个子游戏SG函数值的异或和，即：SG(G) = SG(G1) ^ SG(G2) ^ … ^ SG(Gm)

定理

有向图游戏的某个局面必胜，当且仅当该局面对应节点的SG函数值大于0。
有向图游戏的某个局面必败，当且仅当该局面对应节点的SG函数值等于0。

常规-Nim游戏

#include <iostream>

using namespace std;

const int N = 100010;

int main()
{
    int n;
    scanf("%d", &n);
    
    int res = 0;
    while (n --)
    {
        int x;
        scanf("%d", &x);
        res ^= x;
    }
    
    if (res) puts("Yes");
    else puts("No");
    
    return 0;
}

台阶-Nim游戏

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int main()
{
    int n;
    scanf("%d", &n);

    int res = 0;
    for (int i = 1; i <= n; i ++ )
    {
        int x;
        scanf("%d", &x);
        if (i & 1) res ^= x;
    }

    if (res) puts("Yes");
    else puts("No");

    return 0;
}

集合-Nim游戏

D58AFD439ED72CF24BB8C6860A0B818D.jpgF9733CE7743AB71E8ECEF77AAE759922.jpg

#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_set>

using namespace std;

const int N = 110, M = 10010;

int n, m;
int s[N], f[M];


int sg(int x)
{
    if (f[x] != -1) return f[x];

    // 局部变量的递归
    unordered_set<int> S;
    for (int i = 0; i < m; i ++ )
    {
        int sum = s[i];
        if (x >= sum) S.insert(sg(x - sum));
    }

    for (int i = 0; ; i ++ )
        if (!S.count(i))
            return f[x] = i;
}


int main()
{
    cin >> m;
    for (int i = 0; i < m; i ++ ) cin >> s[i];
    cin >> n;

    memset(f, -1, sizeof f);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int x;
        cin >> x;
        res ^= sg(x);
    }

    if (res) puts("Yes");
    else puts("No");

    return 0;
}

拆分-Nim游戏

#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_set>

using namespace std;

const int N = 110;


int n;
int f[N];


int sg(int x)
{
    if (f[x] != -1) return f[x];

    unordered_set<int> S;
    for (int i = 0; i < x; i ++ )
        for (int j = 0; j <= i; j ++ )
            S.insert(sg(i) ^ sg(j));

    for (int i = 0;; i ++ )
        if (!S.count(i))
            return f[x] = i;
}


int main()
{
    cin >> n;

    memset(f, -1, sizeof f);

    int res = 0;
    while (n -- )
    {
        int x;
        cin >> x;
        res ^= sg(x);
    }

    if (res) puts("Yes");
    else puts("No");

    return 0;
}

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

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

相关文章

第四十八天学习记录：工作相关：Qt resizeEvent 的诡异问题

第四十八天学习记录：工作相关：Qt resizeEvent 的诡异问题

今天&#xff0c;在做一个新项目时&#xff0c;发现一个诡异的问题。 在软件初次打开的时候&#xff0c;会调用一次resizeEvent(QResizeEvent *sizechangeevent)函数来对主界面控件大小以及位置进行一次调整。 但由于窗口在设计的时候用的一个大小&#xff0c;而在打开软件后…
阅读更多...
基于全志D1-H的Tina Linux SPI主从通信验证实录

基于全志D1-H的Tina Linux SPI主从通信验证实录

本文转载自&#xff1a;https://bbs.aw-ol.com/topic/3031 作者 whycan矿工-小叶 背景 主控: D1H板卡: 两块哪吒开发板(以下简称为主机, 从机)操作系统: Tina Linux 2.0 问题 验证D1H芯片SPI主从机通信. 硬件接线 主机SPI从机SPI19SPI1_MOSISPI1_MOSI1921SPI1_MISOSPI1_M…
阅读更多...
Git切换用户；Git提交之后是别人的用户怎么办？

Git切换用户；Git提交之后是别人的用户怎么办？

Git切换用户 前言解决方法1.删除计算机凭证2.Idea控制台切换 前言 前几天在入职之后&#xff0c;公司的电脑上仍然储存了之前用户的信息&#xff0c;比如git。 我在创建分支、提交代码的时候会遇到这样的问题&#xff1a; 登录的是我自己的账号&#xff0c;但是在git动态里缺…
阅读更多...
借助TeeChart图表控件，创建本地静态、实时浏览器图表

借助TeeChart图表控件，创建本地静态、实时浏览器图表

Steema是全球领先的图表类控件公司&#xff0c;总部设在西班牙的巴塞罗那附近&#xff0c;Steema公司的VCL图表报表控件在全球拥有极高知名度。TeeChart可以在微软的Visual Studio、Office和.NET以及Java和PHP开发平台中使用&#xff0c;也可以作为本地Javascript-HTML5使用。 …
阅读更多...
Python新手怎么兼职，用Python在家兼职赚钱的4个方法

Python新手怎么兼职，用Python在家兼职赚钱的4个方法

随着人工智能技术的发展&#xff0c;各行各业都在发生着变化&#xff0c;每天AI&#xff08;人工智能&#xff09;新技术都在冲击着各行各业&#xff0c;比如WPS的智能设计、阿里的鲁班等等&#xff0c;总有一种干死干活不如早点掌握新技能的感觉&#xff0c;避免心中的小慌张。…
阅读更多...
DAY 65 mysql的高可用之MHA集群

DAY 65 mysql的高可用之MHA集群

MHA概述 什么是 MHA MHA&#xff08;MasterHigh Availability&#xff09;是一套优秀的MySQL高可用环境下故障切换和主从复制的软件。 MHA 的出现就是解决MySQL 单点故障的问题。 MySQL故障切换过程中&#xff0c;MHA能做到0-30秒内自动完成故障切换操作。 MHA能在故障切换…
阅读更多...
基于原子化思想的 Vue3 组件库 UnoCSS UI

基于原子化思想的 Vue3 组件库 UnoCSS UI

UnoCSS UI 项目地址前言Monorepo 项目架构UnoCSS UI 的模块设计PNPM Monorepo 常用操作: --filter, -wMonorepo 中的依赖管理项目整体结构 基于原子化 CSS 的组件封装方式原子化 CSS 基础原子化 VS 内联样式原子化 VS class 原子化对组件封装的影响unocss-ui/components 项目结…
阅读更多...
HashTable 在蚂蚁转化归因中的极致运用

HashTable 在蚂蚁转化归因中的极致运用

作者&#xff1a;开七 蚂蚁集团数据技术专家 本文围绕 hash cluster 表运用及 Shuffle 过程原理进行讨论&#xff0c;欢迎各位开发者加入大数据计算 MaxCompute 社区&#xff1a;https://developer.aliyun.com/group/maxcompute 概述 蚂蚁的转化归因在初期运行两个多小时的情况…
阅读更多...
Facebook拆分的深度思考：社交媒体真的是必需品吗？

Facebook拆分的深度思考：社交媒体真的是必需品吗？

在当今数字化时代&#xff0c;社交媒体已经成为我们日常生活中不可或缺的一部分。而Facebook作为其中的巨头之一&#xff0c;不可否认地对人们的社交行为和信息传播产生了巨大的影响。 然而&#xff0c;随着越来越多的争议和讨论浮出水面&#xff0c;我们有必要进行深入思考&a…
阅读更多...
文档处理新探究成果——前沿技术CCIG文档图像智能分析论坛分享

文档处理新探究成果——前沿技术CCIG文档图像智能分析论坛分享

目录 前言 一、文档分析与识别最新研究 二、视觉-语言预训练模型及迁移学习 三、篡改文本图像的生成与检测技术 四、智能文档处理技术在工业界的应用与挑战 总结 前言 图文智能处理前沿技术一直是我所关注的技术&#xff0c;尤其在现在集成多态大模型的基础之上&#xff0…
阅读更多...
关于PCBA元器件布局的重要性

关于PCBA元器件布局的重要性

SMT贴片加工逐步往高密度、细间距的设计发展&#xff0c;元器件的最小间距设计&#xff0c;需考虑SMT厂家的经验和工艺完善程度。元器件最小间距的设计&#xff0c;除了保证SMT焊盘间安全距离外&#xff0c;还应考虑元器件的可维护性。 器件布局时保证安全间距 1、安全距离跟…
阅读更多...
设计模式-简单例子理解适配器模式、装饰器模式

设计模式-简单例子理解适配器模式、装饰器模式

文章目录 一、适配器模式1. 要点2. Demo 二、装饰器模式1. 要点2. Demo 三、区别 本文参考&#xff1a; 基本原理&#xff1a;装饰器模式 | 菜鸟教程 (runoob.com) 基本原理&#xff1a;适配器模式 | 菜鸟教程 (runoob.com) 优缺点和区别&#xff0c;装饰模式&#xff1a;适配器…
阅读更多...
微服务流量控制组件Sentinel

微服务流量控制组件Sentinel

1 简介 Sentinel是阿里开源的项目&#xff0c;是一款面向分布式服务架构的轻量级流量控制组件&#xff0c;主要以流量为切入点&#xff0c;从流量控制、熔断降级、系统自适应保护等多个维度来保障服务的稳定性。 核心思想是&#xff1a;根据对应资源配置的规则来为资源执行相…
阅读更多...
西米支付：“中止”支付牌照，汇卡支付机构“失联”

西米支付：“中止”支付牌照，汇卡支付机构“失联”

近日&#xff0c;又一家支付公司因“失联”被列入了经营异常名录。 工商信息显示&#xff0c;目前被“中止”中的持牌支付机构广东汇卡商务服务有限公司&#xff08;简称“汇卡支付”&#xff09;因“通过登记的住所或者经营场所无法联系” 被广州市市场监督管理局列入经营异常…
阅读更多...
网络进阶学习：单臂路由（灵魂五问）

网络进阶学习：单臂路由（灵魂五问）

单臂路由&#xff08;灵魂五问&#xff09; 一问&#xff1a;什么是单臂路由&#xff1f;二问&#xff1a;单臂路由这一概念怎么出现的&#xff1f;三问&#xff1a;单臂路由解决什么问题&#xff1f;能不能用其他方式取代单臂路由?四问&#xff1a;单臂路由最合适的应用场景&…
阅读更多...
电脑E盘被不小心格式化了？别急，介绍三种数据恢复方法

电脑E盘被不小心格式化了？别急，介绍三种数据恢复方法

电脑E盘格式化后如何恢复数据&#xff1f;意外的电脑E盘格式化或许是每个人都遇到过的问题。然而&#xff0c;当您发现您的重要数据已经丢失时&#xff0c;您可能会感到沮丧甚至绝望。但请不要担心。在本文中&#xff0c;我们将介绍一些有助于您找回数据的方法&#xff0c;希望…
阅读更多...
2023年5月DAMA-CDGA/CDGP数据治理认证咋样

2023年5月DAMA-CDGA/CDGP数据治理认证咋样

DAMA认证为数据管理专业人士提供职业目标晋升规划&#xff0c;彰显了职业发展里程碑及发展阶梯定义&#xff0c;帮助数据管理从业人士获得企业数字化转型战略下的必备职业能力&#xff0c;促进开展工作实践应用及实际问题解决&#xff0c;形成企业所需的新数字经济下的核心职业…
阅读更多...
uvc驱动ioctl分析下

uvc驱动ioctl分析下

uvc驱动ioctl分析下 文章目录 uvc驱动ioctl分析下uvc_ioctl_enum_input枚举输入uvc_query_ctrl__uvc_query_ctrluvc_ioctl_g_input 获取输入uvc_ioctl_s_input 设置输入uvc_query_v4l2_ctrluvc_ioctl_queryctrl查询控制器uvc_ioctl_query_ext_ctrl查询扩展控制器 uvc_ioctl_g_c…
阅读更多...
系统分析师经典易错题，解题思路二

系统分析师经典易错题，解题思路二

企业应用集成（Enterprise Application Integration EAI）技术企业应用集成技术可以消除信息孤岛，它将多个企业信息系统连接起来，实现无缝集成，使他们就像一个整体一样。EAI是伴随着企业信息系统的发展而产生和演变的，企业的价值取向是推动EAI技术发展的原动力，而EAI的实现…
阅读更多...
煤矿电子封条系统 yolov7网络模型

煤矿电子封条系统 yolov7网络模型

煤矿电子封条系统通过yolov7网络模型算法&#xff0c;煤矿电子封条系统可以实现对煤矿井下人员的出入管理&#xff0c;提高对煤矿井下人员的监管效果。YOLOv7 的策略是使用组卷积来扩展计算块的通道和基数。研究者将对计算层的所有计算块应用相同的组参数和通道乘数。然后&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023