牛客小白月赛101

最新推荐文章于 2025-06-03 19:56:39 发布
最新推荐文章于 2025-06-03 19:56:39 发布
阅读量2.3k 收藏 25
点赞数 50
分类专栏： 牛客竞赛 文章标签： 算法 数据结构 c++ stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_74754298/article/details/142406939
版权

比赛链接

https://ac.nowcoder.com/acm/contest/90072

A题 tb的区间问题

思路

实际上是求长度为 n − k n-k n−k的区间的和的最大值。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int n, k;
int a[N], sum[N];
void solve()
{
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        sum[i] = sum[i - 1] + a[i];
    }
    int ans = 0;
    int len = n - k;
    for (int i = 1; i + len - 1 <= n; i++)
    {
        int j = i + len - 1;
        ans = max(ans, sum[j] - sum[i - 1]);
    }
    cout << ans << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}

B题 tb的字符串问题

思路

用栈从前往后模拟，类似于括号匹配。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
int n;
string s;
void solve()
{
    cin >> n >> s;
    stack<char> st;
    for (int i = 0; i < n; i++)
    {
        if (st.empty())
        {
            st.push(s[i]);
        }
        else
        {
            if ((s[i] == 'c' && st.top() == 'f') || (s[i] == 'b' && st.top() == 't'))
            {
                st.pop();
            }
            else
                st.push(s[i]);
        }
    }
    cout << st.size() << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}

C题 tb的路径问题

思路

打表观察样例即可。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
int n;
void solve()
{
    cin >> n;
    if (n == 1)
    {
        cout << 0 << endl;
        return;
    }
    if (n == 2)
    {
        cout << n << endl;
        return;
    }
    if (n == 3)
    {
        cout << 4 << endl;
        return;
    }
    if (n % 2 == 0)
    {
        cout << 4 << endl;
    }
    else
        cout << 6 << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}

D题 tb的平方问题

思路

n n n最大为 1 e 3 1e3 1e3，因此我们可以先用前缀和进行预处理，之后暴力枚举每一个连续子数组，对于和为完全平方数的连续子数组，我们对整个区间的个数加 1 1 1。

因此，本题便转化为了区间加减的问题，可以使用树状数组进行求解。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e3 + 5;
int n, q;
int a[N], s[N];
struct BIT
{
    const static int maxnum = 1e3 + 10;
    int tree[maxnum];
    int lowbit(int x)
    {
        return (x) & (-x);
    }
    void add(int idx, int x)
    {
        for (int pos = idx; pos < maxnum; pos += lowbit(pos))
        {
            tree[pos] += x;
        }
    }
    int query(int n)
    {
        int ans = 0;
        for (int pos = n; pos; pos -= lowbit(pos))
        {
            ans += tree[pos];
        }
        return ans;
    }
    int query(int a, int b)
    {
        return query(b) - query(a - 1);
    }
    void init(int n)
    {
        for (int i = 0; i <= n + 2; i++)
            tree[i] = 0;
    }
} tree;
bool check(int x)
{
    int op = sqrt(x);
    if (op * op == x)
        return true;
    return false;
}
void solve()
{
    cin >> n >> q;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        s[i] = s[i - 1] + a[i];
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = i; j <= n; j++)
        {
            int sum = s[j] - s[i - 1];
            if (check(sum))
            {
                tree.add(i, 1);
                tree.add(j + 1, -1);
            }
        }
    }
    while (q--)
    {
        int x;
        cin >> x;
        cout << tree.query(x) << endl;
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}

E题 tb的数数问题

思路

找每个没有出现的数，他的倍数都是false的，其余的都是true。

时间复杂度为调和级数。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e6 + 5;
int n;
int a[N];
bool st[N];
void solve()
{
    cin >> n;
    map<int, int> mp;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        mp[a[i]]++;
    }
    int ans = 0, high = *max_element(a + 1, a + 1 + n);
    for (int i = 1; i <= high; i++)
    {
        if (mp.count(i) && !st[i])
        {
            ans++;
        }
        else
        {
            for (int j = i; j <= high; j += i)
            {
                st[j] = true;
            }
        }
    }
    cout << ans << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}

F题 tb的排列问题

思路

对于任意一个 b i b_{i} bi​，当且仅当 p o s [ b i ] > i + w pos[b_{i}] > i + w pos[bi​]>i+w时无解。

如果 b i b_{i} bi​没有在数组 a a a中出现过，那么 b i b_{i} bi​可以出现在 ≤ i + w \le i + w ≤i+w的任何地方。因此我们可以使用类似于前缀和的方式， c n t [ i ] cnt[i] cnt[i]表示有多少个数字可以放到 i i i上，又因为前面已经假设放了 p r e pre pre个数字，那么当前位置就有 p r e pre pre个数字不能放了，所以答案与 c n t [ i ] − p r e cnt[i]-pre cnt[i]−pre相乘。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long i64;
const int N = 2e5 + 5;
template <int P>
struct MInt
{
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}

    static int Mod;
    constexpr static int getMod()
    {
        if (P > 0)
        {
            return P;
        }
        else
        {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_)
    {
        Mod = Mod_;
    }
    constexpr int norm(int x) const
    {
        if (x < 0)
        {
            x += getMod();
        }
        if (x >= getMod())
        {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const
    {
        return x;
    }
    explicit constexpr operator int() const
    {
        return x;
    }
    constexpr MInt operator-() const
    {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const
    {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) &
    {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) &
    {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) &
    {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) &
    {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs)
    {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs)
    {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs)
    {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs)
    {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a)
    {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a)
    {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs)
    {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs)
    {
        return lhs.val() != rhs.val();
    }
};

template <>
int MInt<0>::Mod = 998244353;

template <int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 998244353;
using Z = MInt<P>;
int n, w;
int a[N], b[N];
void solve()
{
    cin >> n >> w;
    vector<int> pos(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        if (a[i] != -1)
        {
            pos[a[i]] = i;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        cin >> b[i];
    }
    vector<int> cnt(n + 1);
    for (int i = n; i >= 1; i--)
    {
        int high = min(n, i + w);
        if (pos[b[i]] && pos[b[i]] > high)
        {
            cout << 0 << endl;
            return;
        }
        if (!pos[b[i]])
            cnt[high]++;
    }

    Z ans = 1;
    int pre = 0;
    for (int i = n; i >= 1; i--)
    {
        cnt[i - 1] += cnt[i];
        if (a[i] != -1)
            continue;
        ans *= (cnt[i] - pre);
        pre++;
    }
    cout << ans << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    cin >> T;
    for (int i = 1; i <= T; i++)
    {
        solve();
    }
    return 0;
}
牛客小白月赛101（栈、差分、调和级数、滑动窗口）
mldl_的博客
09-20 1161
牛客小白月赛101题解。（栈、差分、调和级数、滑动窗口）
牛客小白月赛110（打表、容斥+二分、区间dp、DFS）
mldl_的博客
02-20 824
牛客小白月赛110（打表、容斥+二分、区间dp、DFS）
牛客小白月赛101（A~E）
wh233z的博客
09-21 774
最近几天没怎么刷题，昨天晚上打的这场牛客月赛打的很烂，隔几天不刷题感觉自己的思维都钝化了，看来每天得刷几题找找手感，不然直接打训练赛容易暴毙。
牛客小白月赛100（思维、模拟、BFS、分块、三元环、并查集）
mldl_的博客
09-10 1205
B题可以理解为所有数据为一组，C题只需要根据 b 数组对 a 数组进行分组，再分别判断即可。枚举所有三元环，同一个三元环的边加入到同一个集合中，最后判断有几个集合。故而，在一定范围内，枚举每个扫雷能力需要的时间取min即可。从起点开始BFS，记录对于起点的相对位移（只记录正方向）。)，相对位移为(x, y)，则 “我” 的坐标为（X。使用一个flag，记录三种状态，分别处理即可。+ y），“另一个我”的坐标为（X。的时间，把 m 提升到。根据题意，模拟翻倍即可。的时间，扫过全部的区间；
牛客小白月赛94（A~D题讲解附代码 EF代码已补）【语法入门 前缀和 简单构造 枚举答案】
2301_80089588的博客
05-24 868
牛客小白月赛94【A~D题讲解附代码】【EF代码已补】
牛客小白月赛98 （个人题解）（补全）
Wzh20060111的博客
07-13 714
前言：昨天晚上自己一个人打的小白月赛（因为准备数学期末已经写烦了），题目难度感觉越来越简单了（不在像以前一样根本写不了一点，现在看题解已经能看懂一点了），能感受到自己在不断进步，希望在暑假能更努力一点吧，，少打点游戏，多学学算法，还有web的学习也要抓起来了，这几天不是在看高数就是在打游戏，感觉好堕落。
牛客小白月赛101（下）
u014114223的博客
09-25 1004
对于任意的 n，最有效的策略通常是利用 n 的因数特性，特别是 n与其自身的最大公约数总是 n，这意味着可以直接从 (1,1) 通过“传送”到达 (n,n)，前提是找到一条路径使得中途能够访问值为 n 的格子。基于对不同 n值的手动分类处理，但这并不是一个通用或高效的解决方案。，将其值累加上前一个位置的值，即。为起点的满足条件的子区间数量。为起点的满足条件的子区间数量。，将其元素值累加到前缀和数组。次，每次读取一个查询下标。
牛客小白月赛101题解A~F
Johncronus的博客
09-22 912
整体的难度其实个人感觉比较低，前5个题的话应该在cf大概1000~1300的状态，整体相对难度不大。然后F是一个不是很防AK的防AK，我做着应该是有点吃力了。
【牛客】小白月赛101E-tb的数数问题
2302_78926002的博客
09-21 272
【代码】【牛客】小白月赛101E-tb的数数问题。
牛客小白月赛101 （A-E）C++ 题解
ros275229的博客
09-21 627
牛客小白月赛101 （A-E）C++ 题解
牛客小白月赛 90 （全）
2301_80105412的博客
04-05 486
牛客小白月赛 90
[cf] The 2021 Sichuan Provincial Collegiate Programming Contest 赛前训练
qq_34364611的博客
10-23 454
目录前言 :A - Chuanpai思路CODEK - K-skip Permutation思路CODED - Rock Paper Scissors思路CODEH - Nihongo wa Muzukashii Desu思路CODEB - Hotpot思路CODE 前言 : 传送门 : 全程一直再写,但是基本都是模拟体验还好 因为规定半小时的训练赛,当开到EEE题,刚刚开始算法的时候就没时间了,只有半小时了 A - Chuanpai 思路 范围很小,看了一下可以直接暴力 + 特判即可 CODE #incl
DP小题单【4】
weixin_50909982的博客
11-27 721
经典换根DP： #include<bits/stdc++.h> using namespace std; const int N=3e6+10; #define int long long int ne[N],h[N],e[N],idx; int f[N],siz[N],n,m,ans[N]; int dp1[N],dp2[N],msz1[N],msz2[N]; void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] =
【MATLAB去噪算法】基于CEEMD联合小波阈值去噪算法(第三期)
最新发布
yuchunyu12的博客
06-03 623
CEEMD联合小波阈值去噪算法相关文献。
leetcode hot100刷题日记——33.二叉树的层序遍历
weixin_54248223的博客
05-31 622
题目描述情况1：不确定行数和列数情况2：已知行数和列数情况3：已知行数但不知道列数情况4：已知列数但不知道行数。
leetcode-hot-100 (矩阵）
weixin_73557167的博客
06-01 842
矩阵
牛客小白月赛109
04-02
### 关于牛客小白月赛109的信息 目前并未找到关于牛客小白月赛109的具体比赛信息或题解内容[^5]。然而，可以推测该赛事可能属于牛客网举办的系列算法竞赛之一，通常这类比赛会涉及数据结构、动态规划、图论等经典算法问题。 如果要准备类似的赛事，可以通过分析其他场次的比赛题目来提升自己的能力。例如，在牛客小白月赛13中，有一道与二叉树相关的题目，其核心在于处理树的操作以及统计最终的结果[^3]。通过研究此类问题的解决方法，能够帮助理解如何高效地设计算法并优化时间复杂度。 以下是基于已有经验的一个通用解决方案框架用于应对类似场景下的批量更新操作： ```python class TreeNode: def __init__(self, id): self.id = id self.weight = 0 self.children = [] def build_tree(n): nodes = [TreeNode(i) for i in range(1, n + 1)] for node in nodes: if 2 * node.id <= n: node.children.append(nodes[2 * node.id - 1]) if 2 * node.id + 1 <= n: node.children.append(nodes[2 * node.id]) return nodes[0] def apply_operations(root, operations, m): from collections import defaultdict counts = defaultdict(int) def update_subtree(node, delta): stack = [node] while stack: current = stack.pop() current.weight += delta counts[current.weight] += 1 for child in current.children: stack.append(child) def exclude_subtree(node, total_nodes, delta): nonlocal root stack = [(root, False)] # (current_node, visited) subtree_size = set() while stack: current, visited = stack.pop() if not visited and current != node: stack.append((current, True)) for child in current.children: stack.append((child, False)) elif visited or current == node: if current != node: subtree_size.add(current.id) all_ids = {i for i in range(1, total_nodes + 1)} outside_ids = all_ids.difference(subtree_size.union({node.id})) for idx in outside_ids: nodes[idx].weight += delta counts[nodes[idx].weight] += 1 global nodes nodes = {} queue = [root] while queue: curr = queue.pop(0) nodes[curr.id] = curr for c in curr.children: queue.append(c) for operation in operations: op_type, x = operation.split(' ') x = int(x) target_node = nodes.get(x, None) if not target_node: continue if op_type == '1': update_subtree(target_node, 1) elif op_type == '2' and target_node is not None: exclude_subtree(target_node, n, 1) elif op_type == '3': path_to_root = [] temp = target_node while temp: path_to_root.append(temp) if temp.id % 2 == 0: parent_id = temp.id // 2 else: parent_id = (temp.id - 1) // 2 if parent_id >= 1: temp = nodes[parent_id] else: break for p in path_to_root: p.weight += 1 counts[p.weight] += 1 elif op_type == '4': pass # Implement similarly to other cases. result = [counts[i] for i in range(m + 1)] return result ``` 上述代码片段展示了针对特定类型的树形结构及其操作的一种实现方式。尽管它并非直接对应小白月赛109中的具体题目，但它提供了一个可借鉴的设计思路。 ####
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值