51nod 1964 陵陵曾玩的数论题 （笛卡尔树+dsu合并）

于 2021-07-26 10:08:45 发布
阅读量70 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45948940/article/details/119103607
版权

求解 所有子区间的最大lcmlcm %mod 的乘积
在这里插入图片描述

#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <cmath>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
const int mod_1 = mod - 1;
const int MAXN = 100003;
const int Sqr = (int)sqrt(MAXN) + 1;
struct Io
{
    char A[MAXN * 4],*L,*R;
    int count;
    Io()
    {
        L = R = A;
        count = MAXN * 4;
    }
    void Io_fread()
    {
        L = A;
        R = A + fread(A, sizeof(char), count, stdin);
    }
    int read()
    {
        int  tmp = 0;
        if (L == R)
        {
            Io_fread();
            if (L == R)return 0;
        }
        while (*L<'0'||*L>'9')
        {
            L++;
            if (L == R)
            {
                Io_fread();
                if (L == R)return 0;
            }
        }
        while (*L >= '0'&&*L <= '9')
        {
            tmp = tmp * 10 + (*L - '0');
            L++;
            if (L == R)
            {
                Io_fread();
                if (L == R)return tmp;
            }
        }
        return tmp;
    }
}I;
int used[MAXN];
int buf[MAXN];
int G[MAXN];
int tmp[MAXN];
int tmp2[MAXN];
int nxt[MAXN];
int fst[MAXN];
int bnxt[MAXN];
int bfst[MAXN];
int queue[MAXN];
int stk[MAXN];
int *wnxt = tmp, *wfst = tmp2, *AL = tmp, *AR = tmp2, *C = used;
int ans = 1;

struct node
{
    int c[2];
    int L, R;
    node()
    {
        L = R = c[0] = c[1] = 0;
    }
};

struct Decare
{
    node A[MAXN];
    int root;
    int deep;
    Decare()
    {
        root = 0;
        deep = 1;
    }
    void _insert(int key, int inof)
    {
        if (inof == 0)
        {
            root = deep++;
            tmp[root] = key;
            return;
        }
        while (inof)
        {
            if (tmp[inof] >= key)
            {
                tmp[deep] = key;
                G[deep] = inof;
                A[deep].c[0] = A[inof].c[1];
                A[inof].c[1] = deep;
                G[A[deep].c[0]] = deep;
                deep++;
                return;
            }
            inof = G[inof];
        }
        tmp[deep] = key;
        A[deep].c[0] = root;
        G[root] = deep;
        root = deep++;
    }
    void insert(int key)
    {
        _insert(key, deep - 1);
    }
    void BFS(int root)
    {
        memset(tmp, 0, sizeof tmp);
        int l = 0, r = 1;
        stk[0] = root;
        while (l < r)
        {
            int v = stk[l++];
            if (A[v].c[0])    stk[r++] = A[v].c[0];
            if (A[v].c[1])    stk[r++] = A[v].c[1];
        }
        int n = r;
        while (r--)
        {
            int v = stk[r];
            tmp[v] ++;
            tmp[G[v]] += tmp[v];
        }
        tmp[0] = 0;
        l = 0;    r = 1;
        A[root].L = 1;
        A[root].R = n;
        A[0].L = 1;
        A[0].R = 0;
        while (l<r)
        {
            int v = stk[l++];
            A[A[v].c[0]].L = A[v].L;
            A[A[v].c[0]].R = A[A[v].c[0]].L + tmp[A[v].c[0]] - 1;
            A[A[v].c[1]].L = A[A[v].c[0]].R + 2;
            A[A[v].c[1]].R = A[A[v].c[1]].L + tmp[A[v].c[1]] - 1;
            if (A[v].c[0])   stk[r++] = A[v].c[0];
            if (A[v].c[1])   stk[r++] = A[v].c[1];
        }
        memset(tmp, 0, sizeof tmp);
        memset(G, 0, sizeof G);
        A[0].L = 1;
        A[0].R = 0;
    }
}D;

int Pow(int a, int b)
{
    int tmp = 1;
    while (b)
    {
        if (b & 1)
            tmp = (LL)tmp*a%mod;
        a = (LL)a*a%mod;
        b >>= 1;
    }
    return tmp;
}

int A[MAXN];

int find_nxt(int k, int B)
{
    int top = -1, d = k;
    while (bnxt[d] <= B)
    {
        stk[++top] = d;
        d = bnxt[d];
    }
    while (top>-1)
    {
        int x = stk[top--];
        if (bnxt[x] == nxt[x])wnxt[x] = A[x] * (bnxt[x] - x);
        wnxt[x] += wnxt[bnxt[x]];
        bnxt[x] = d;
    }
    return wnxt[k] + (B - d + 1)*A[d];
}

int find_fst(int k, int B)
{
    int top = -1, d = k;
    while (bfst[d] >= B)
    {
        stk[++top] = d;
        d = bfst[d];
    }
    while (top>-1)
    {
        int x = stk[top--];
        if (bfst[x] == fst[x]) wfst[x] = A[x] * (x - bfst[x]);
        wfst[x] += wfst[bfst[x]];
        bfst[x] = d;
    }
    return wfst[k] + (d - B + 1)*A[d];
}

void BFS_1(int root, int P)
{
    int l = 0, r = 1;
    queue[0] = root;
    while (l < r)
    {
        int v = queue[l++];
        if (D.A[v].c[0])queue[r++] = D.A[v].c[0];
        if (D.A[v].c[1])queue[r++] = D.A[v].c[1];
    }
    while (r--)
    {
        int v = queue[r];
        int *c = D.A[v].c;
        int L = D.A[v].L;
        int R = D.A[v].R;
        if (L == R)
        {
            G[P] = (G[P] + (LL)A[L] * buf[L] % (mod_1)) % mod_1;
            continue;
        }

        int mid = (c[0]) ? D.A[c[0]].R + 1 : D.A[c[1]].L - 1;

        if ((D.A[c[0]].R - D.A[c[0]].L + 1)<(D.A[c[1]].R - D.A[c[1]].L + 1))
        {
            for (int i = mid; i >= L; i = fst[i])
            {
                if (nxt[i] <= R)
                {
                    int bk = fst[i] < L ? L : fst[i] + 1;
                    G[P] += ((LL)(i - bk + 1)*(nxt[i] - mid) % (mod - 1))*((LL)A[i] * buf[mid] % (mod - 1)) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;
                    G[P] += (LL)(i - bk + 1)*(buf[mid]) % (mod - 1)*find_nxt(nxt[i], R) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;
                }
                else
                {
                    int bk = fst[i]<L ? L : fst[i] + 1;
                    G[P] += ((LL)(i - bk + 1)*(R - mid + 1) % (mod - 1))*((LL)A[i] * buf[mid] % (mod - 1)) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;
                }
            }
        }
        else
        {
            for (int i = mid; i <= R; i = nxt[i])
            {
                if (fst[i] >= L)
                {
                    int bk = nxt[i]>R ? R : nxt[i] - 1;
                    G[P] += ((LL)(bk - i + 1)*(mid - fst[i]) % (mod - 1))*((LL)A[i] * buf[mid] % (mod - 1)) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;;
                    G[P] += (LL)(bk - i + 1)*buf[mid] % (mod - 1)*find_fst(fst[i], L) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;
                }
                else
                {
                    int bk = nxt[i]>R ? R : nxt[i] - 1;
                    G[P] += ((LL)(bk - i + 1)*(mid - L + 1) % (mod - 1))*((LL)A[i] * buf[mid] % (mod - 1)) % (mod - 1);
                    if (G[P] >= mod - 1)G[P] -= mod - 1;
                }
            }
        }
    }
}

void BFS_2(int root)
{
    int l = 0, r = 1;
    queue[0] = root;
    while (l < r)
    {
        int v = queue[l++];
        if (D.A[v].c[0])queue[r++] = D.A[v].c[0];
        if (D.A[v].c[1])queue[r++] = D.A[v].c[1];
    }

    while (r--)
    {
        root = queue[r];
        int *c = D.A[root].c;
        int L = D.A[root].L;
        int R = D.A[root].R;
        if (L == R)
        {
            G[A[buf[L]]] = (G[A[buf[L]]] + buf[L]) % mod_1;
            AL[root] = AR[root] = C[root] = A[buf[L]];
            continue;
        }
        int mid = (c[0]) ? D.A[c[0]].R + 1 : D.A[c[1]].L - 1;
        int tot = (LL)(mid - L + 1)*(R - mid + 1) % mod_1;
        if ((D.A[c[0]].R - D.A[c[0]].L) < (D.A[c[1]].R - D.A[c[1]].L))
        {
            AR[root] = (LL)AR[c[0]] * AR[c[1]] % mod;
            AL[root] = (LL)AL[c[0]] * AL[c[1]] % mod;
            C[root] = (LL)C[c[0]] * C[c[1]] % mod;
            for (int i = mid; i >= L; i--)
            {
                int &bk = nxt[i];
                if (bk <= mid)continue;
                int a = A[buf[i]];
                if (bk > R)
                {
                    G[a] += (LL)buf[mid] * (i - L + 1) % mod_1*(R - mid + 1) % mod_1;
                    if (G[a] >= mod_1)G[a] -= mod_1;
                    AR[root] = (LL)AR[root] * Pow(A[buf[i]], R - mid + 1) % mod;
                    int b = (i == mid) ? (fst[i]<L ? L : fst[i] + 1) : mid + 1;
                    AL[root] = (LL)AL[root] * Pow(A[buf[i]], mid - b + 1) % mod;
                    if ((i == mid && fst[i] >= L) || i != mid)
                        C[c[0]] = (LL)C[c[0]] * Pow(A[buf[i]], mod - 2) % mod;
                }
                else
                {
                    //bk<=R
                    int b = tot - (LL)(mid - i)*(bk - mid) % mod_1;
                    if (b < 0)b += mod_1;
                    G[a] += (LL)buf[mid] * b % mod_1;
                    if (G[a] >= mod_1)G[a] -= mod_1;
                    AR[c[1]] = (LL)AR[c[1]] * Pow(A[buf[i]], (LL)(mod - 2)*(R - bk + 1) % mod_1) % mod;
                    C[c[1]] = (LL)C[c[1]] * Pow(A[buf[i]], mod - 2) % mod;
                    if (i != mid)
                    {
                        C[c[0]] = (LL)C[c[0]] * Pow(A[buf[i]], mod - 2) % mod;
                        C[root] = (LL)C[root] * Pow(A[buf[i]], mod - 2) % mod;
                        AL[root] = (LL)AL[root] * Pow(A[buf[i]], mid - i) % mod;
                    }
                    else
                    {
                        C[c[0]] = (LL)C[c[0]] * (fst[i]<L ? 1 : Pow(A[buf[i]], mod - 2)) % mod;
                        C[root] = (LL)C[root] * (fst[i]<L ? 1 : Pow(A[buf[i]], mod - 2)) % mod;
                        AL[root] = (LL)AL[root] * Pow(A[buf[i]], mid + 1 - ((fst[i]<L) ? L : fst[i] + 1)) % mod;
                    }
                    AR[root] = (LL)AR[root] * Pow(A[buf[i]], bk - mid) % mod;//
                }
            }
            ans = (LL)ans*Pow(AR[c[1]], (LL)(mid - L + 1)*buf[mid] % (mod - 1)) % mod;
            AL[root] = (LL)AL[root] * Pow(C[c[1]], mid - L + 1) % mod;
            if (nxt[mid]>R&&fst[mid]<L) C[root] = (LL)C[root] * A[buf[mid]] % mod;
        }
        else
        {
            AR[root] = (LL)AR[c[0]] * AR[c[1]] % mod;
            AL[root] = (LL)AL[c[0]] * AL[c[1]] % mod;
            C[root] = (LL)C[c[0]] * C[c[1]] % mod;
            for (int j = mid; j <= R; j++)
            {
                int &bk = fst[j];
                int a = A[buf[j]];
                if (bk >= mid)continue;
                if (bk < L)
                {
                    G[a] += (LL)buf[mid] * (mid - L + 1) % (mod - 1)*(R - j + 1) % (mod - 1);
                    if (G[a] >= mod - 1)G[a] -= mod - 1;
                    AL[root] = (LL)AL[root] * Pow(A[buf[j]], mid - L + 1) % mod;
                    int b = (j == mid) ? (nxt[j] <= R ? nxt[j] - 1 : R) : mid - 1;
                    AR[root] = (LL)AR[root] * Pow(A[buf[j]], b - mid + 1) % mod;
                    if ((j == mid&&nxt[j] <= R) || j != mid)
                        C[c[1]] = (LL)C[c[1]] * Pow(A[buf[j]], mod - 2) % mod;
                }
                else
                {
                    int b = tot - (LL)(mid - bk)*(j - mid) % mod_1;
                    if (b < 0)b += mod_1;
                    G[a] += (LL)buf[mid] * b % mod_1;
                    if (G[a] >= mod - 1)G[a] -= mod_1;
                    AL[c[0]] = (LL)AL[c[0]] * Pow(A[buf[j]], (LL)(bk - L + 1)*(mod - 2) % mod_1) % mod;
                    C[c[0]] = (LL)C[c[0]] * Pow(A[buf[j]], mod - 2) % mod;
                    if (j != mid)
                    {
                        C[c[1]] = (LL)C[c[1]] * Pow(A[buf[j]], mod - 2) % mod;
                        C[root] = (LL)C[root] * Pow(A[buf[j]], mod - 2) % mod;
                        AR[root] = (LL)AR[root] * Pow(A[buf[j]], j - mid) % mod;
                    }
                    else
                    {
                        C[c[1]] = (LL)C[c[1]] * ((nxt[j] <= R) ? Pow(A[buf[j]], mod - 2) : 1) % mod;
                        C[root] = (LL)C[root] * ((nxt[j] <= R) ? Pow(A[buf[j]], mod - 2) : 1) % mod;
                        AR[root] = (LL)AR[root] * Pow(A[buf[mid]], ((nxt[j]>R) ? R : nxt[j] - 1) - mid + 1) % mod;
                    }
                    AL[root] = (LL)AL[root] * Pow(A[buf[j]], mid - bk) % mod;
                }
            }
            ans = (LL)ans*Pow(AL[c[0]], (LL)(R - mid + 1)*buf[mid] % mod_1) % mod;
            AR[root] = (LL)AR[root] * Pow(C[c[0]], R - mid + 1) % mod;
            if (nxt[mid]>R&&fst[mid]<L) C[root] = (LL)C[root] * A[buf[mid]] % mod;
        }
    }

}

void init(int n)
{
    A[0] = A[n + 1] = 0x3f3f3f3f;
    for (int i = 2; i < Sqr; i++)
    {
        if (used[i])continue;
        for (int j = i; j < MAXN; j += i)    used[j] = 1;

        for (int j = 1; j <= n; j++)
        {
            A[j] = 0;
            int t = buf[j];
            while (t%i == 0)
            {
                A[j]++;
                t /= i;
            }
        }

        memset(tmp, 0, sizeof tmp);
        memset(tmp2, 0, sizeof tmp2);
        stk[0] = 0;

        for (int j = 1, top = 0; j <= n; j++)
        {
            while (A[stk[top]] < A[j])top--;
            bfst[j] = fst[j] = stk[top];
            stk[++top] = j;
        }
        stk[0] = n + 1;

        for (int j = n, top = 0; j; j--)
        {
            while (A[stk[top]] <= A[j])top--;
            bnxt[j] = nxt[j] = stk[top];
            stk[++top] = j;
        }
        BFS_1(D.root, i);
    }
    for (int i = 0; i < MAXN; i++)A[i] = 1;
    for (int i = Sqr; i < MAXN; i++)
    {
        if (used[i])continue;
        for (int j = i; j < MAXN; j += i)
        {
            used[j] = 1;
            A[j] = i;
        }
    }
    memset(tmp, 0, sizeof tmp);
    for (int i = 1; i <= n; i++)
    {
        fst[i] = tmp[A[buf[i]]];
        tmp[A[buf[i]]] = i;
    }
    for (int i = 0; i < MAXN; i++)tmp[i] = n + 1;
    for (int j = n; j; j--)
    {
        nxt[j] = tmp[A[buf[j]]];
        tmp[A[buf[j]]] = j;
    }
    memset(tmp, 0, sizeof tmp);
    memset(tmp2, 0, sizeof tmp2);
    memset(used, 0, sizeof used);
    AL[0] = AR[0] = C[0] = 1;
    BFS_2(D.root);
}

int main()
{
    int n;
    n = I.read();
    for (int i = 1; i <= n; i++)
    {
        buf[i] = I.read();
        D.insert(buf[i]);
    }
    D.BFS(D.root);
    init(n);
    for (int i = 2; i < MAXN; i++) ans = (LL)ans*Pow(i, G[i]) % mod;
    printf("%d\n", ans);
    return 0;
}
Orz_Sponge_Bob
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
51nod 1964 陵陵曾玩的数论题
t56346的博客
08-21 142
题目描述： 腾腾是一名数论大师，经常在51nod上切高分数论题。凭借着高超的实力，拿到了51nod的#2。 陵陵是腾腾的好朋友。2017年1月，他还在苦恼一直都不会刷>=320分数论题。一天，他拿到了栋栋寄来的一道数论题。不幸的是，陵陵看错了这道数论题的题意，他感觉这太难了，于是只能拿去问腾腾：给定一个长度为n的序列a，对于一个区间[l,r]，如果al，al+1……ar的最小公倍数记作lcm，最大值记作max，这个区间[l,r]的价值定义为lcmmaxlcmmax（即lcm的max次幂）。...
51nod的题目标答。
06-07
51nod的题目标答，大家喜欢的可以下载看看，但记住不要复制！！！
51nod 1964 1964 陵陵曾玩的数论题
ZLH_HHHH的博客
12-22 828
https://www.51nod.com/onlineJudge/questionCode.html#!problemId=1964强烈建议在阅读时动手设计一下算法流程。会有助于理解。解决此题。必须知道下面T(n)T(n)的增张速度。T(n)=maxk=1n(T(k−1)+T(n−k)+min(k,n−k+1))T(n)=\max_{k=1}^{n}\big(T(k-1)+T(n-k)+min(k
算法-树的直径（51Nod-2602）.rar
09-16
标题中的“算法-树的直径（51Nod-2602）”指的是一个算法问题，来源于在线编程挑战平台51Nod的第2602题。这道题目通常涉及图论中的树结构以及如何计算树的直径。树的直径是指在所有可能的路径中，最长的一条路径的...
51nod:51nod.com的代码
05-03
51点 51nod.com的代码
最长配对（51Nod-2494）.rar
09-16
标题中的“最长配对（51Nod-2494）”可能指的是一个编程竞赛题目或算法问题，源自51Nod这个在线编程训练平台的第2494个问题。51Nod是一个为程序员提供算法练习的网站，其中的题目涵盖了许多常见的数据结构和算法知识...
51nodProblem_1836.in
12-09
由于文件名及描述提及“51Nod数据”，可以关联到51Nod网站，这是一个知名的在线编程竞赛平台，用于训练算法设计和编程技能。这份文件可能是某个特定问题的数据输入样本，用于测试或验证算法的正确性和效率。 ### ...
【中科院1区】Matlab实现天鹰优化算法AO-RF锂电池健康状态估计算法研究.rar
08-02
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
汽车行业数字化转型报告顶层规划设计.docx
08-02
汽车行业数字化转型报告顶层规划设计.docx
毕业设计，基于ASP.NET+SqlServer开发的企业投资价值分析系统，内含完整源代码，数据库，毕业论文
08-02
毕业设计，基于ASP.NET+SqlServer开发的企业投资价值分析系统，内含完整源代码，数据库，毕业论文 自中国证券市场产生以来，投资者进行投资理财迫切需要有一个科学的理论依据，在众多投资理论体系中，确定企业的价值和股票的价值，是一个重要的流派。著名的投资专家巴非特就是通过分析企业的内在价值，寻找价值被低估的股票，等到市场认可了该企业的价值，再将股票抛出，从而获得了的投机收益，其管理的基金也一度成为世界上最成功的投资基金之一。从西方国家理论界对相关领域的研究结果来看，也取得了一些成果，包括：CAPM 模型、 ICAPM模型、APT模型等，也有人用市盈率方法对股票进行定价。国内在相关的领域也取得了一些研究成果。然而，尽管国内外理论界研究成果较多，但真正适应中国证券市场、适应中国广大投资者的切实有效的理论至今仍是一个空白。在中国这样一个特殊的背景下，股权结构的特殊性、证券市场初创时期的投资性等因素，使得一些模型受到挑战，而且这些模型的精确化程度也受到限制，有必要探求新的思路和方法，为广大的投资者提供切实可靠的操作依据。对股票的价值进行评估必须综合尽可能全面的因素才能使得这些评估更加科
【创新未发表】Matlab实现黑猩猩优化算法Chimp-RF实现风电预测算法研究.rar
08-02
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
蝗虫算法GOA-Kmean-Transformer-LSTM负荷预测【含Matlab源码 6784期】.zip
08-02
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化Kmeans-Transformer-lstm分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化Kmeans-Transformer-lstm预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化Kmeans-Transformer-lstm预测 4.4.3 灰狼算法GWO/狼群算法WPA优化Kmeans-Transformer-lstm预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化Kmeans-Transformer-lstm预测 4.4.5 萤火虫算法FA/差分算法DE优化Kmeans-Transformer-lstm预测 4.4.6 其他优化算法优化Kmeans-Transformer-Lstm预测
java-springboot+vue房地产销售管理系统实现源码(项目源码-说明文档)
08-02
java-springboot+vue房地产销售管理系统 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：Springboot 前端技术：Vue、HTML5、css、JavaScript 关键技术：springboot、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
蜣螂算法DBO-Kmean-Transformer-BiLSTM组合状态识别分类【含Matlab源码 6625期】.zip
08-02
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化Kmeans-Transformer-Bilstm预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化Kmeans-Transformer-Bilstm预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化Kmeans-Transformer-Bilstm预测 4.4.3 灰狼算法GWO/狼群算法WPA优化Kmeans-Transformer-Bilstm预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化Kmeans-Transformer-Bilstm预测 4.4.5 萤火虫算法FA/差分算法DE优化Kmeans-Transformer-Bilstm预测 4.4.6 其他优化算法优化Kmeans-Transformer-Bilstm预测
双对数回归模型的数据（从数学建模国赛c题整理的一部分）
08-02
数学建模里可用的一个模型
java-springboot+vue厨艺交流平台的设计与实现源码(项目源码-说明文档)
08-02
java-springboot+vue厨艺交流平台 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：Springboot 前端技术：Vue、HTML5、css、JavaScript 关键技术：springboot、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
【创新未发表】Matlab实现牛顿拉夫逊优化算法NRBO-RF实现风电预测算法研究.rar
08-02
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
艺恩2024年7月文娱行业市场观察.pdf
08-02
【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场观察.pdf【艺恩】2024年7月文娱行业市场
基于SSM的荆州理工职业学院网站 Javaee项目 ssm项目
最新发布
08-02
资源详情：https://blog.csdn.net/2302_78191516/article/details/140880383
51nod3204分数运算
07-09
对于题目51nod3204，这是一个分数运算的问题。很抱歉，由于我无法直接访问外部网站或查找特定问题的详细答案，我不能为你提供该问题的具体解答。然而，我可以为您提供一般的分数运算知识和算法，以帮助您解决该问题...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值