Codeforces CodeTON Round 8(Div.1 + Div.2) A~E

Codeforces比赛题目分析与解答
最新推荐文章于 2025-11-24 15:27:16 发布
原创 最新推荐文章于 2025-11-24 15:27:16 发布 · 889 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #OI #codeforces

A. Farmer John’s Challenge (模拟)

题意：

构造一个长度为nnn的数组，将这些数组围成一个圈（顺时针）从任意一个位置打开，有且仅有 kkk个非降序排列的数组。

分析：

k=1k=1k=1时，升序输出1−n1-n1−n，n=kn=kn=k时，全111即可。其他情况都是−1-1−1。

代码：

#include <bits/stdc++.h>

using namespace std;
const int mod = 1e9 + 7;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        if (k == 1) {
            for (int i = 1; i <= n; i++)
                cout << i << " ";
            cout << endl;
        } else if (n == k) {
            for (int i = 1; i <= n; i++)
                cout << 1 << " ";
            cout << endl;
        } else
            cout << -1 << endl;
    }
    return 0;
}

B.Bessie and MEX （思维）

题意：

给出一个长度为 nnn 的数组 aaa ，根据 aaa 构造出一个排列 ppp 。数组 aaa 的构造使得 aia_iai​ = MEX(p1,p2,…,pi)−pi\texttt{MEX}(p_1, p_2, \ldots, p_i) - p_iMEX(p1​,p2​,…,pi​)−pi​ ，其中数组的 MEX\texttt{MEX}MEX 是该数组中没有出现的最小非负整数。

分析：

ai>0a_i>0ai​>0，填入当前的最小值，同时更新最小值，ai<0a_i<0ai​<0时，mexmexmex没有更新，加上绝对值即可。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int a[N], p[N];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        int minval = 0;
        for (int i = 1; i <= n; i++) {
            if (a[i] > 0) {
                p[i] = minval;
                minval = a[i] + minval;
            } else {
                p[i] = minval - a[i];
            }
        }
        for (int i = 1; i <= n; i++)
            cout << p[i] << " ";
        cout << endl;
    }
    return 0;
}

C1. Bessie’s Birthday Cake (Easy Version) (数学)

题意：

贝西从她最好的朋友埃尔西那里收到了一个生日蛋糕，它是一个边长为 nnn 的正多边形。蛋糕的顶点按顺时针方向从 111 排列到 nnn 。你和贝西将选择其中的一些顶点在蛋糕上切出不相交的对角线。换句话说，对角线的端点必须是所选顶点的一部分。
为了保持一致性，贝西只想分发三角形的蛋糕。蛋糕块的大小并不重要，整个蛋糕也不一定要分成三角形（蛋糕中可以有其他形状，但不计算在内）。
贝西已经选择了 xxx 个顶点，可以用来组成对角线。她希望你选择的其他顶点不超过yyy ，这样她能分出的三角形蛋糕的数量就能达到最大。
贝西最多能分出多少块三角形蛋糕？
此题保证y=0y=0y=0

分析：

假设对答案有贡献的点叫有效点,可以发现如果两个点之间正好只有一个点,那么这个点也是有效的,答案是总的有效点数减222.

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int a[N];

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, x, y, cnt;
        cin >> n >> x >> y;
        cnt = x - 2;
        for (int i = 1; i <= x; i++)
            cin >> a[i];
        sort(a + 1, a + x + 1);
        for (int i = 1; i < x; i++) {
            if (a[i] + 1 == a[i + 1] - 1) {
                cnt++;
            }
        }
        if (a[x] == n - 1 && a[1] == 1)
            cnt++;
        else if (a[x] == n && a[1] == 2)
            cnt++;
        cout << cnt << endl;
    }
    return 0;
}

C2.Bessie’s Birthday Cake (Hard Version) (数学)

题意：

贝西从她最好的朋友埃尔西那里收到了一个生日蛋糕，它是一个边长为 nnn 的正多边形。蛋糕的顶点按顺时针方向从 111 排列到 nnn 。你和贝西将选择其中的一些顶点在蛋糕上切出不相交的对角线。换句话说，对角线的端点必须是所选顶点的一部分。
为了保持一致性，贝西只想分发三角形的蛋糕。蛋糕块的大小并不重要，整个蛋糕也不一定要分成三角形（蛋糕中可以有其他形状，但不计算在内）。
贝西已经选择了 xxx 个顶点，可以用来组成对角线。她希望你选择的其他顶点不超过yyy ，这样她能分出的三角形蛋糕的数量就能达到最大。
贝西最多能分出多少块三角形蛋糕？

分析：

通过简单版本发现，每次操作可以让有效点数加222，但是如果一段只剩下333个点,那么可以一次性操作让有效点数加333。同时发现奇数间隔可以获得的贡献更大，所以优先操作间距短的奇数长度区间间隔，再操作偶数区间间隔。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, x, y;
        cin >> n >> x >> y;
        vector<int> a(x);
        for (int i = 0; i < x; i++)
            cin >> a[i];
        sort(a.begin(), a.end());
        int sum = x;
        vector<int> tmp[2];
        for (int i = 0; i < x; i++) {
            int len = a[(i + 1) % x] - a[i] - 1;
            if (len < 0)
                len += n;
            if (len == 1)
                sum += 1;
            if (len > 1) {
                tmp[len % 2].push_back(len);
            }
        }
        for (int i = 1; i >= 0; i--) {
            sort(tmp[i].begin(), tmp[i].end());
            for (auto u: tmp[i]) {
                if (u % 2 == 1) {
                    int num2 = (u - 3) / 2;
                    int t = min(y, num2);
                    y -= t;
                    sum += t * 2;
                    int num3 = 1;
                    t = min(y, num3);
                    y -= t;
                    sum += t * 3;
                } else {
                    int num2 = u / 2;
                    int t = min(y, num2);
                    y -= t;
                    sum += t * 2;
                }
            }
        }
        cout << sum - 2 << endl;
    }
    return 0;
}

D.Learning to Paint (dp)

题意：

艾尔西正在学习如何绘画。她的画布上有 nnn 个单元格，编号从 111 到 nnn ，她可以画任何（可能是空）单元格子集。
艾尔西有一个二维数组 aaa ，她将用这个数组来评估绘画作品。假设一幅画中绘画单元格的最大连续间隔为 [l1,r1],[l2,r2],…,[lx,rx][l_1,r_1],[l_2,r_2],\ldots,[l_x,r_x][l1​,r1​],[l2​,r2​],…,[lx​,rx​] 。这幅画的美丽值是所有 1≤i≤x1 \le i \le x1≤i≤x 中 ali,ria_{l_i,r_i}ali​,ri​​ 的总和。
有 2n2^n2n 种方法可以绘制条形图。请帮助艾尔西找出在所有这些方法中，前kkk大的美丽值。这kkk种美丽值可以相同，但要保证至少有kkk种画法。

分析：

fff表示使用前iii个位置的前kkk大和，但是位置iii不一定要涂色。ggg表示使用前iii个位置且以iii开头的前kkk大和，保证位置iii为涂色开头。即f[i][j]f[i][j]f[i][j]表示使用前iii个位置，第jjj大的和。g[i][j]g[i][j]g[i][j]表示 使用前iii个位置，iii涂色 且i−1i-1i−1不涂色 第jjj大的和。
维护f[i]f[i]f[i]，可以用优先队列，从 g[1...i]g[1...i]g[1...i]转移，同时维护g[1...i]g[1...i]g[1...i]最大的值，取前kkk个用于更新f[i]f[i]f[i]。在更新g[i+1]g[i+1]g[i+1]时，因为iii不涂色，以i−1i-1i−1及前面的位置结尾都可，因此就是 g[i+1]=f[i−1];g[i+1]=f[i-1];g[i+1]=f[i−1];

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
#define PII pair<LL, LL>
const int mod = 1e9 + 7;
const int INF = 1e9;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        vector<vector<int>> a(n + 1, vector<int>(n + 1));
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                cin >> a[i][j];
            }
        }
        vector<vector<int>> f(n + 1, vector<int>(k, -INF));
        vector<vector<int>> g(n + 2, vector<int>(k, -INF));
        g[1][0] = 0;
        f[0][0] = 0;
        vector<int> c(k);
        vector<int> p(n + 1);
        for (int i = 1; i <= n; i++) {
            priority_queue<PII > tmp;
            for (int j = 1; j <= i; j++) {
                tmp.push({g[j][0] + a[j][i], j});
                p[j] = 0;
            }
            for (int t = 0; t < k; t++) {
                auto [s, j] = tmp.top();
                tmp.pop();
                f[i][t] = s;
                p[j]++;
                tmp.push({g[j][p[j]] + a[j][i], j});
            }
            int l = 0, r = 0;
            for (int t = 0; t < k; t++) {
                c[t] = max(f[i - 1][l], f[i][r]);
                if (f[i - 1][l] > f[i][r])
                    l++;
                else
                    r++;
            }
            f[i] = c;
            g[i + 1] = f[i - 1];
        }

        for (int i = 0; i < k; i++) {
            cout << f[n][i] << " ";
        }
        cout << endl;
    }
    return 0;
}

E.Farm Game (组合数)

题意：

农夫 NhojNhojNhoj 带着他的奶牛来到农夫 JohnJohnJohn 的农场玩游戏！农夫约翰的农场可以用一条在 000 和 l+1l + 1l+1 点有墙的数线来模拟。农场里有 2n2n2n 头奶牛，其中 nnn 头属于 FJFJFJ，另外 nnn 头属于 FNFNFN。他们把每头牛都放在一个不同的点上，FJFJFJ 的牛和 FNFNFN 的牛都不相邻。如果两头奶牛之间没有其他奶牛，它们就是相邻的。
在一次下棋中，农夫选择了 kkk(1≤k≤n)(1 \leq k \leq n)(1≤k≤n) 和一个方向（左或右）。然后，农夫选择 kkk 头奶牛，并将它们朝所选方向移动一个位置。农场主不能将自己的奶牛移动到墙上或其他农场主的奶牛上。如果一位农夫不能移动任何奶牛，那么他就输了。FJFJFJ先开始游戏，进行第一个回合。
给定 lll 和 nnn ，求如果两个农夫都以最佳方式下棋，农夫约翰可能获胜的棋局配置数。对局可能无限期地进行下去，在这种情况下没有农民获胜。如果有任何 iii 与 aia_iai​ 或 bib_ibi​ 不同，则该配置与另一种配置不同。输出答案，请将答案对998244353998244353998244353取模。

分析：

首先发现a[i]a[i]a[i]在 b[i]b[i]b[i]前面 和 a[i]a[i]a[i]在 b[i]b[i]b[i]后面这两种情况实际是一样，只需要计算其中一种情况，最后答案乘222即可。
如果 b[i]−a[i]−1b[i]-a[i]-1b[i]−a[i]−1 不全为偶数，那么就是 FJFJFJ 必胜。因为全为偶数是必败态，又由于kkk至少为111，如果全是偶数，FJFJFJ 转移一次后 FNFNFN 获得的是必胜态。如果不全是偶数，FJFJFJ 可以转移一次全变成偶数，FNFNFN 获得的就是必败态了。
我们逆向考虑，用总答案数减去全为偶数的情况。总答案数为C(l,2×n)C(l,2\times n)C(l,2×n)。当(b[i]−a[i]−1)(b[i]-a[i]-1)(b[i]−a[i]−1)全为偶数时，考虑空地怎么插在牛之间，(a,b)(a,b)(a,b)内只能插偶数块空地，枚举插入(a,b)(a,b)(a,b)内的空地对的个数为mmm。(a,b)(a,b)(a,b)一共有nnn 组，答案为C(n+m−1,m−1)C(n+m−1,m−1)C(n+m−1,m−1)。
剩下的空地插在(b,a)(b,a)(b,a)和(0,a[0])(0,a[0])(0,a[0]),(b[n],l+1)(b[n],l+1)(b[n],l+1)内，一共n+1n+1n+1组，用同样的方法计算。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 5;
const int mod = 998244353;

template<const int T>
struct ModInt {
    const static int mod = T;
    int x;

    ModInt(int x = 0) : x(x % mod) {}

    ModInt(long long x) : x(int(x % mod)) {}

    int val() { return x; }

    ModInt operator+(const ModInt &a) const {
        int x0 = x + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    ModInt operator-(const ModInt &a) const {
        int x0 = x - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    ModInt operator*(const ModInt &a) const { return ModInt(1LL * x * a.x % mod); }

    ModInt operator/(const ModInt &a) const { return *this * a.inv(); }

    bool operator==(const ModInt &a) const { return x == a.x; };

    bool operator!=(const ModInt &a) const { return x != a.x; };

    void operator+=(const ModInt &a) {
        x += a.x;
        if (x >= mod)
            x -= mod;
    }

    void operator-=(const ModInt &a) {
        x -= a.x;
        if (x < 0)
            x += mod;
    }

    void operator*=(const ModInt &a) { x = 1LL * x * a.x % mod; }

    void operator/=(const ModInt &a) { *this = *this / a; }

    friend ModInt operator+(int y, const ModInt &a) {
        int x0 = y + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }

    friend ModInt operator-(int y, const ModInt &a) {
        int x0 = y - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }

    friend ModInt operator*(int y, const ModInt &a) { return ModInt(1LL * y * a.x % mod); }

    friend ModInt operator/(int y, const ModInt &a) { return ModInt(y) / a; }

    friend ostream &operator<<(ostream &os, const ModInt &a) { return os << a.x; }

    friend istream &operator>>(istream &is, ModInt &t) { return is >> t.x; }

    ModInt pow(int64_t n) const {
        ModInt res(1), mul(x);
        while (n) {
            if (n & 1)
                res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    ModInt inv() const {
        int a = x, b = mod, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        if (u < 0)
            u += mod;
        return u;
    }
};

using mint = ModInt<mod>;

mint fact[N], invfact[N];

void init() {
    fact[0] = invfact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i;
    invfact[N - 1] = fact[N - 1].inv();
    for (int i = N - 2; i; i--)
        invfact[i] = invfact[i + 1] * (i + 1);
}

inline mint C(int a, int b) {
    if (a < 0 || b < 0 || a < b)
        return 0;
    return fact[a] * invfact[b] * invfact[a - b];
}

int main() {
    init();
    int t;
    cin >> t;
    while (t--) {
        int l, n;
        cin >> l >> n;
        mint ans = C(l, 2 * n);
        int k = l - 2 * n;
        for (int m = 0; 2 * m <= k; m++) {
            mint res = C(n + m - 1, n - 1);
            res *= C((n + 1) + (k - 2 * m) - 1, (n + 1) - 1);
            ans -= res;
        }
        ans *= 2;
        cout << ans << endl;
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。

Codeforces Round 1015, Div. 1 + Div. 2
2301_81692739的博客
04-16 1165
f (b) 是 mex(b) 的最小可能值，所以最多进行m次操作，视作 进行 m 次。设n 放在位置 x ,则 max(a[x-1],a[x])=n，应满足 n%x=x-1。​ n / (m+1) ，所以 f (b) 最大为 n / (m+1)-对于所有 2≤i≤n ，满足 max(pi−1,pi)mod。​ 每个数字最多删除m 次，要想留下来，至少存在 m+1 个。每次删除 k 个 ，删除m 次，最后剩下 n-m * k。进行排列， f (b)最大为 n - m * k。
Teza Round 1 (Codeforces Round 1015, Div. 1 + Div. 2)
gyc271828的博客
04-26 1639
观察样例有偶数一定不行，奇数的话我们就把1放在第一个，最大的放在第二个，其他顺次排列就ok了int x;cin>>x;a[1]=x;i<=x;i<=x;cout<<endl;return;cin>>t;return 0;
D. Traffic Lights 【Codeforces Round 1038, Div. 1 + Div. 2】
Flower#的博客
07-20 393
D. Traffic Lights 【Codeforces Round 1038, Div. 1 + Div. 2】 暴力枚举（brute force）动态规划（dp）图论（graphs）最短路（shortest paths）
Ethflow Round 1 (Codeforces Round 1001, Div. 1 + Div. 2)(A-E1)
Vcoistnt的博客
01-31 1297
新年好，最近有点忙了，过几天再把D题补上.....于2025/2/6补上D题
Codeforces Round 947 (Div. 1 + Div. 2)
weixin_73897113的博客
07-28 991
如果数组一开始不是从小到大的，可以如果满足，那么只需要进行一次操作，就可以将数组变为从小到大。选择的前缀和后缀需要满足，都是从小到大的并且后缀的最后一个元素要小于前缀的第一个元素。例如，如果 a=[3,1,4,1,5]a=[3,1,4,1,5] ，我们可以选择 x=[3,1] 和 y=[4,1,5],设置a:=y+x=[4,1,5,3,1]可以进行如下操作，选择一个区间[l,r]，然后将这一区间的数全变为这个区间的中位数。有一个长度为n的数组a，你需要进行操作，使得数组a中的元素都相同。
Ethflow Round 1 (Codeforces Round 1001, Div. 1 + Div. 2)(前三题)
qq_68286180的博客
01-27 1305
在一次操作中，您可以从 s 中选择一个非空的子序列 t，使得 t 中任何两个相邻的字符都是不同的。然后，翻转 t 中的每个字符（0 变为 1，1 变为 0）。要让过程永续下去必须要走过每个点，判断是否存在一个点 i 会在以该点为起点，向左来回或向右来回时消失，判断条件为i<=2*max(i-1,n-i)。如果某个时钟的时间在某一秒内为 0，即使您可以移动到该时钟并在该秒内重置其时间，您仍然会输。dfs(tmp)为当前序列tmp的最大值，tmp可能会有重复计算的情况，使用memo记忆化。都是 s 的子序列。
Atto Round 1 (Codeforces Round 1041, Div. 1 + Div. 2) vp记录,详细题解（Solved ABC，vp rank 4662）
Transient_ovo的博客
08-08 957
本文包含三个编程题的解题思路和AC代码： A题要求判断数组三元组是否满足特定条件，通过分析发现只有当数组元素全相同且不含0时才满足条件。 B题模拟Hamid的逃脱过程，计算在最优策略下需要多少天才能逃出房间，通过分析左右墙的位置关系确定最优解。 C题是关于两人博弈的预算问题，Ali和Bahamin通过选择最优策略使预算最小或最大，通过排序和对特殊情况的处理找到最优解。 三题均给出了详细的思路分析和对应的AC代码实现。
Rayan Programming Contest 2024 - Selection (Codeforces Round 989, Div. 1 + Div. 2) 题解 (A～E)
Ciallo～
12-01 1562
上限是lcmab，直接枚举即可。
Codeforces Global Round 29 (Div. 1 + Div. 2)（A~C）题解
2402_89341493的博客
09-22 1518
本文解析了Codeforces比赛中的A、B、C三题。A题（Shortest Increasing Path）要求计算从(0,0)到(x,y)的最小移动步数，需满足步长严格递增且奇数/偶数步方向固定，通过分析不同情况得出2步或3步的解法。B题（Multiple Construction）需要构造含重复数的特定数组，巧妙利用对称分布满足距离条件。C题（Rabbits）考察空花盆中兔子的方向安排，核心在于判断被花夹住的连续空盆数量是否为奇数，若存在奇数段则无法避免跳跃。三题均注重思维分析，通过特殊构造和分段实现
Codeforces Round 959(Div. 1 + Div. 2)A~C
小白的博客
07-20 920
差点爆零了，最近div2打的越来越艰难了，好多不会累死，脑子完全不够用，上次div3刚上的绿就掉了。
Codeforces Round 947 (Div. 1 + Div. 2 ABCDE) 视频讲解
Edward Shi的博客
05-26 1577
Codeforces Round 947 (Div. 1 + Div. 2)（A ~ E 题 视频讲解）
Codeforces Round 947 (Div. 1 + Div. 2) A~F
Code_Shark的博客
05-31 1215
摩卡喜欢数组，所以在出发前，巴祖卡送给她一个由n个正整数组成的数组a作为礼物。现在，摩卡想知道数组aaxya:=yx例如，如果是a31415，我们可以选择x31和y415，满足axy。然后，我们可以设置a:=yx41531。我们还可以选择x31415和y，满足axy。然后，我们可以设置a:=yx31415。注意，我们不能选择x311和y45，也不能选择x13和y514。
Codeforces Round #758 (Div.1 + Div. 2)
Code_Shark的博客
12-18 464
A. Find Array 题意： 给一个数字nnn要求寻找出一个长为nnn的数组aaa，保证： 1≤ai≤1091\le a_i \le 10^91≤ai​≤109 a1<a2<⋯<ana_1<a_2<\dots<a_na1​<a2​<⋯<an​ 对于i≥2i\ge 2i≥2，aia_iai​不可以被ai−1a_{i-1}ai−1​整除 分析： 直接返回222到n+1n+1n+1即可 代码： #include<bits/stdc++.h&gt
Codeforces Round 959(Div. 1 + Div. 2) A~E
Code_Shark的博客
07-31 530
佩特看了谢尔盖的数据流，得出了一个矩阵a，由n行和m列组成（第i行和第j列中的数字表示为aij​），其中包含了从1到n⋅m的所有整数。但是他并不喜欢这样的数字排列，现在他想出一个新的矩阵b，由n行和m列组成，同样包含从1到n⋅m的所有整数，这样对于任意的1≤i≤n1≤j≤m来说，aij​bij​都成立。给你矩阵a，请构造出符合Petr要求的矩阵b，或者确定这是不可能的。
Codeforces Round 959 (Div. 1 + Div. 2 ABCDEFG 题) 文字讲解+视频讲解
Edward Shi的博客
07-20 1005
Codeforces Round 959 (Div. 1 + Div. 2 ABCDEFG 题) 文字讲解+视频讲解
2025年全国青少年信息素养大赛复赛真题（算法创意实践挑战赛C++初中组试卷1：带解析）（7月6日试卷）
王老师青少年编程
11-21 713
2025年全国青少年信息素养大赛复赛真题（算法创意实践挑战赛C++初中组试卷1：带解析）（7月6日试卷）
代码随想录 63.不同路径Ⅱ
最新发布
m0_63814538的博客
11-24 277
4.确定遍历顺序：从递归公式可以看出一定是从左到右一层一层的遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j]和dp[i][j - 1]一定是有数值的。所以本题的初始化代码如下所示：一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理。1.确定dp数组（dp table）及其下标的含义：dp[i][j]表示从（0，0）出发，到（i，j）有dp[i][j]条不同的路径。下标（0，j）的初始化情况同理。
【Python TensorFlow】 TCN-LSTM时间序列卷积长短期记忆神经网络时序预测算法（附代码）
q22837656的博客
11-24 290
本文提出了一种结合时间卷积网络(TCN)和长短期记忆网络(LSTM)的混合预测算法(TCN-LSTM)，用于解决传统时间序列预测方法在捕捉长期依赖和局部特征方面的不足。该算法利用TCN的并行计算能力和LSTM的序列建模优势，通过五步流程实现：数据准备、预处理、网络构建、模型训练和评估。代码示例展示了数据读取、特征提取、归一化处理及模型训练过程，支持多种输入输出模式。实验结果表明，该混合模型能有效提升时序预测性能，适用于电力负荷、风电场功率等多种应用场景。
算法：二叉搜索树的最近公共祖先
czlczl20020925的博客
11-24 333
下面是详细的解释，说明为什么这是必然的。对于我们当前所在的任何节点。
(Codeforces Round 1036, Div. 1 + Div. 2)
07-09
Codeforces Round 1036 是一场同时面向 Div.1 和 Div.2 参赛者的比赛，通常这类比赛会包含多个具有挑战性的编程题目，涵盖算法、数据结构、数学等多个领域。比赛的题解和题目信息可以帮助参赛者回顾解题思路，提升...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值