Educational Codeforces Round 165 (Div. 2) A~E

关注

原创最新推荐文章于 2026-02-26 00:20:53 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

【电力负荷预测】项目介绍 MATLAB实现基于BO-Transformer-LSTM贝叶斯优化算法（BO）优化Transformer-LSTM组合模型进行居民用户多步电力负荷预测（含模型描述及部分示例内容概要：本文介绍了一个基于BO-Transformer-LSTM的组合模型，用于实现居民用户多步电力负荷预测的完整项目实例。该模型融合Transformer的全局注意力机制与LSTM的局部时序记忆能力，构建能够捕捉长时依赖与周期性特征的深度学习架构，并引入贝叶斯优化（BO）自动搜索最优超参数组合，提升预测精度与训练效率。项目涵盖从原始数据清洗、特征工程、滑动窗口样本构建、模型设计到超参数优化、反归一化及多步误差评估的全流程，强调时间顺序划分以防止信息泄露，并通过周期编码、外生变量融合等方式增强数据表达能力。文中提供了详细的MATLAB代码示例，包括数据预处理、网络搭建、贝叶斯优化配置和预测结果评估等关键步骤。适合人群：具备一定机器学习和时间序列分析基础，熟悉MATLAB编程环境，从事电力系统预测、智能电网、负荷管理等相关领域的研究人员、工程师及研究生。使用场景及目标：①应用于居民级或多用户聚合负荷的短期至中期多步预测（如未来24小时）；②服务于配电系统运行调度、需求响应基线设定、家庭能源管理系统优化、分布式能源协调控制等实际工程场景；③为科研提供可复现的深度学习+贝叶斯优化的技术路线参考。阅读建议：此资源以实际项目为导向，建议读者结合提供的代码逐步实现并调试模型，重点关注数据质量控制、时间特征编码、组合网络结构设计与贝叶斯优化稳定性之间的协同关系，在实践中深入理解多步预测中的误差累积机制与超参数敏感性问题。立即下载

A.Two Friends (思维)

题意：

小 $A$ 想开一个派对。他有 $n$ 个朋友，他希望至少有 $2$ 个朋友参加他的派对。
$i$ 这个朋友最好的朋友是 $p_i$ 。所有的 $p_i$ 都是不同的，对于每一个 $\in [1, n]$ ， $pi≠ip_i \ne i$ 都是不同的。
小 $A$ 可以向朋友发出邀请。如果第 $i$ 个朋友和第 $p_i$ 个朋友都收到了邀请，那么第 $i$ 个朋友就会来参加聚会（注意，第 $p_i$ 个朋友不必真的来参加聚会）。每份邀请函都恰好发给其中一位朋友。
计算至少要发出多少份邀请函，才能让朋友来参加聚会？

分析：

如果有两人互为最好朋友则发两张，否则三张必定能解决。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 5;
int a[N];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int flag = 0;
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        for (int i = 1; i <= n; i++) {
            if (a[a[i]] == i)
                flag = 1;
        }
        if (flag)
            cout << 2 << endl;
        else
            cout << 3 << endl;
    }
    return 0;
}

B.Shifts and Sorting （思维）

题意：

给定一个只含 $01$ 的二进制序列，每次可选择一段序列将其尾元素移至首位，代价为序列长度，问最少用多少代价可以构造一个非降序序列。

分析：

问题等价于将所有的 $0$ 移到 $1$ 前面，一次最多把一个 $0$ 移到 $1$ 前面对。并且对于一个 $0$ ，最少的操作数一定是前面 $1$ 的个数 $+ 1$ 。只需要统计前缀的 $1$ 的个数即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int t;
    cin >> t;
    while (t--) {
        string s;
        cin >> s;
        LL num = 0;
        LL ans = 0;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == '1')
                num++;
            else if (num)
                ans += num + 1;
        }
        cout << ans << endl;
    }
    return 0;
}

C.Minimizing the Sum (dp)

题意：

给你一个长度为 $n$ 的整数数组 $a$ 。可以执行以下操作：选择数组中的一个元素 $a_i$ ，使得 $a_{i+1}=a_i$ 或者 $a_{i-1}=a_i$ 。
你的任务是计算执行最多 $k$ 次上述操作数组的最小总和。

分析：

$d p [i] [j]$ 表示前 $i$ 个数，执行了 $j$ 次操作的最小和。从左到右枚举当前最小值的位置 $i$ ，枚举操作数 $x$ ，操作是把一个区间的值都变成最小值 $a_i$ ，区间长度是 $x + 1$ ，可以直接枚举区间的左边界 $l$ ，区间右边界就是 $r = l + x$ 。有转移方程： $d p [r] [t + x] = min (d p [r] [t + x], d p [l - 1] [t] + (a [i] * (x + 1)));$ 。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, k;
        cin >> n >> k;
        vector<LL> a(n + 1), s(n + 1);
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        vector<vector<LL>> dp(n + 1, vector<LL>(k + 1, 1e16));
        dp[0][0] = 0;
        for (int i = 1; i <= n; i++) {
            for (int x = 0; x <= k; x++) {
                for (int l = i; l >= i - x && l >= 1; l--) {
                    int r = l + x;
                    if (r > n)
                        continue;
                    for (int t = 0; t <= k - x; t++) {
                        dp[r][t + x] = min(dp[r][t + x], dp[l - 1][t] + (a[i] * (x + 1)));
                    }
                }
            }
        }
        LL ans = 1e16;
        for (int i = 0; i <= k; i++) {
            ans = min(dp[n][i], ans);
        }
        cout << ans << endl;
    }
    return 0;
}

D. Shop Game (贪心)

题意：

总共有 $n$ 件商品， $A l i ce$ 可以用 $a_i$ 的价格购入， $B o b$ 可用 $b_i$ 的价格从 $A l i ce$ 处购买，并且 $B o b$ 可以不花钱获得额外的 $k$ 件物品，询问双方在最优策略下， $A l i ce$ 可获得的收益最大为多少。

分析：

我们按照 $b_i$ 的值从大到小排序。枚举边界 $i$ ，从 $1 - i$ 的部分选 $k$ 个， $i + 1 - n$ 部分任意选择。 $1 - i$ 部分选的 $k$ 个一定是这次选择里最大的 $k$ 个 $b$ ，这部分选的某个位置对答案的贡献是 $a_i$ ，将问题转化成选择 $k$ 个最小的 $a_i$ ，因此维护一个 $a_i$ 单调队列。
考虑到 $i + 1 - n$ 部分任意选，由于最大的 $k$ 个 $b$ 已经选了，这部分选的某个位置对答案的贡献是 $b_i-a_i$ 。因为这部分是任意选的，为了让答案更大，对答案的贡献就是 $b_i-a_i$ 结果为正值的和。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, k;
        cin >> n >> k;
        vector<int> a(n), b(n);
        for (int i = 0; i < n; i++)
            cin >> a[i];
        for (int i = 0; i < n; i++)
            cin >> b[i];
        vector<int> tmp(n);
        iota(tmp.begin(), tmp.end(), 0);
        sort(tmp.begin(), tmp.end(), [&](int x, int y) {
            if (b[x] == b[y]) return a[x] > a[y];
            return b[x] > b[y];
        });
        LL ans = 0;
        LL l = 0, r = 0;
        priority_queue<int> p;
        for (int i = 0; i < k; i++) {
            int j = tmp[i];
            p.push(a[j]);
            l -= a[j];
        }
        for (int i = k; i < n; i++) {
            int j = tmp[i];
            r += max(0, b[j] - a[j]);
        }
        ans = max(ans, l + r);
        for (int i = k; i < n; i++) {
            int j = tmp[i];
            p.push(a[j]);
            l -= a[j];
            l += p.top();
            p.pop();
            r -= max(0, b[j] - a[j]);
            ans = max(ans, l + r);
        }
        cout << ans << endl;
    }
    return 0;
}

E. Unique Array (数据结构)

题意：

给你一个长度为 $n$ 的整数数组 $a$ 。如果有一个整数在 $a$ 的子段中恰好出现一次，那么这个子段就是唯一的。
现在可以执行以下任意次数（可能为零）的操作：从数组中选择一个元素，然后用任意整数替换它。
你的任务是计算上述操作的最少次数，以使数组 $a$ 的所有子段都是唯一的。

分析：

首先对于每个位置 $a_i$ ，找到其前面和后面第一个与之相同的位置记为 $pre_i$ 和 $nxt_i$ ，那么对于 $a_i$ ，能使得所有 $\in [pre_i+1,i],r \in [i,nxt_i-1]$ 的区间都变得符合要求。
这符合二维数点，通过用扫描线找到不满足要求的区间。假设对于每个点 $i$ 作为右端点时,其最大的不满足要求的左端点为 $l_i$ 。我们可以按照 $l_i$ 排序，然后每次贪心地修改最大的 $l_i$ ，然后记录修改过的最小的为 $l_i$ 为 $min v a l$ ，可以发现如果某些 $\ge minval$ ，那么这个位置也不再需要修改了,可以跳过。可以发现这样是最优的。

代码：

#include <bits/stdc++.h>

using namespace std;
const int mod = 998244353;
const int INF = 1e9;
struct Info {
    int mn = INF, mnnow = 0;
};
using Tag = int;

Info operator+(const Info &a, const Info &b) {
    return a.mn < b.mn ? a : b;
}

void apply(Info &x, Tag &a, Tag f) {
    x.mn += f;
    a += f;
}

template<class Info, class Tag>
struct LazySegmentTree {
    int n;
    vector<Info> info;
    vector<Tag> tag;

    LazySegmentTree() {}

    LazySegmentTree(int n, Info _init = Info()) {
        init(vector<Info>(n, _init));
    }

    LazySegmentTree(const vector<Info> &_init) {
        init(_init);
    }

    void init(const vector<Info> &_init) {
        n = (int) _init.size();
        info.assign((n << 2) + 1, Info());
        tag.assign((n << 2) + 1, Tag());
        function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (l == r) {
                info[p] = _init[l - 1];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m + 1, r);
            pull(p);
        };
        build(1, 1, n);
    }

    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }

    void apply(int p, const Tag &v) {
        ::apply(info[p], tag[p], v);
    }

    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }

    void change(int p, int l, int r, int x, const Info &v) {
        if (l == r) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x <= m) {
            change(2 * p, l, m, x, v);
        } else {
            change(2 * p + 1, m + 1, r, x, v);
        }
        pull(p);
    }

    void change(int p, const Info &v) {
        change(1, 1, n, p, v);
    }

    Info ask(int p, int l, int r, int x, int y) {
        if (l > y || r < x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return ask(2 * p, l, m, x, y) + ask(2 * p + 1, m + 1, r, x, y);
    }

    Info ask(int l, int r) {
        return ask(1, 1, n, l, r);
    }

    void change(int p, int l, int r, int x, int y, const Tag &v) {
        if (l > y || r < x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        change(2 * p, l, m, x, y, v);
        change(2 * p + 1, m + 1, r, x, y, v);
        pull(p);
    }

    void change(int l, int r, const Tag &v) {
        return change(1, 1, n, l, r, v);
    }
};

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> pre(n + 1), nxt(n + 1);
        vector<int> a(n + 1);
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        {
            vector<int> last(n + 1);
            for (int i = 1; i <= n; i++) {
                pre[i] = last[a[i]];
                last[a[i]] = i;
            }
        }
        {
            vector<int> last(n + 1, n + 1);
            for (int i = n; i >= 1; i--) {
                nxt[i] = last[a[i]];
                last[a[i]] = i;
            }
        }
        vector<vector<pair<int, int>>> now(n + 1);
        for (int i = 1; i <= n; i++) {
            now[nxt[i] - 1].push_back({i, 1});
            now[i - 1].push_back({i, 0});
        }
        vector<Info> init(n);
        for (int i = 0; i < n; i++) {
            init[i] = {0, i + 1};
        }
        LazySegmentTree<Info, Tag> seg(init);
        set<pair<int, int>> s;
        for (int i = n; i >= 1; i--) {
            for (auto [x, type]: now[i]) {
                if (type) {
                    seg.change(pre[x] + 1, x, 1);
                } else {
                    seg.change(pre[x] + 1, x, -1);
                }
            }
            auto [mn, mnnow] = seg.ask(1, i);
            if (mn == 0) {
                s.insert({mnnow, i});
            }
        }
        int ans = 0;
        int tmp = n + 1;
        while (!s.empty()) {
            if (prev(s.end())->second >= tmp) {
                s.erase(prev(s.end()));
            } else {
                ans += 1;
                tmp = prev(s.end())->first;
                s.erase(prev(s.end()));
            }
        }
        cout << ans << endl;
    }
    return 0;
}