【秋招突围】2024届秋招笔试-小红书笔试题-第三套-三语言题解(Java/Cpp/Python)

🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员

✨ 本系计划跟新各公司春秋招的笔试题

💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导

👏 感谢大家的订阅➕ 和 喜欢💗

📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注CSDN同名公主号领取，会在飞书进行同步的跟新。

📖 写在前面

初夏来临 秋招还会远吗？

前不久春招也算是圆满结束咯，大家有拿到心仪的 offer吗？
接下来互联网的秋招也快来啦，小伙伴们有开始准备了吗？
本次给大家带来24届秋招 小红书 的笔试题目三语言解析(Java/Python/Cpp)

文末有清隆学长的笔试陪伴打卡小屋活动介绍

✨丰富的打卡奖励等你来领哦，大厂笔试题汇总，笔试面试经验贴，算法笔试模版…

💽 有兴趣的小伙伴们也可以了解一下，不要错过啦~

🎀 01.小红书的话题热度统计

问题描述

小红书是一个很受年轻人欢迎的社区平台。在小红书上，用户可以发布和浏览各种话题的笔记。平台会根据用户对话题的讨论热度，统计出热门话题。

现在给定 $n$ 个用户发布的话题，每个话题由一个长度不超过 $50$ 的仅包含大小写字母和数字的字符串表示。当一个话题出现次数大于等于 $3$ 次时，就称为热门话题。

请你按照话题成为热门话题的时间顺序，输出所有的热门话题。注意，这里以一个话题第 $3$ 次出现的时间作为该话题成为热门话题的时间。

输入格式

第一行包含一个正整数 $n$，表示话题的总数。

接下来 $n$ 行，每行一个字符串，表示一个话题。

输出格式

第一行输出一个正整数 $m$，表示热门话题的数量。

接下来 $m$ 行，每行一个字符串，表示一个热门话题。按照话题成为热门话题的时间顺序输出。

样例输入

5
apple
apple
blue
apple
green

样例输出

1
apple

数据范围

$1\le n\le 10^4$

题解

我们可以使用哈希表来解决这个问题。具体步骤如下：

1. 使用一个哈希表 $cnt$ 统计每个话题出现的次数。
2. 使用另一个哈希表 $inRes$ 记录话题是否已经被加入到结果中。
3. 遍历所有话题，对于每个话题：
   • 将其在 $cnt$ 中的计数值加 $1$。
   • 如果该话题出现次数大于等于 $3$，且之前没有被加入过结果，则将其加入结果数组。
4. 遍历结束后，结果数组中按顺序保存了所有的热门话题。

时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。其中 $n$ 为话题的总数。

参考代码

• Python

from collections import defaultdict

n = int(input())
cnt = defaultdict(int)
in_res = defaultdict(bool)
res = []

for _ in range(n):
    topic = input()
    cnt[topic] += 1
    if cnt[topic] >= 3 and not in_res[topic]:
        res.append(topic)
        in_res[topic] = True

print(len(res))
for topic in res:
    print(topic)

• Java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Map<String, Integer> cnt = new HashMap<>();
        Map<String, Boolean> inRes = new HashMap<>();
        List<String> res = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            String topic = sc.next();
            cnt.put(topic, cnt.getOrDefault(topic, 0) + 1);
            if (cnt.get(topic) >= 3 && !inRes.getOrDefault(topic, false)) {
                res.add(topic);
                inRes.put(topic, true);
            }
        }

        System.out.println(res.size());
        for (String topic : res) {
            System.out.println(topic);
        }
    }
}

• Cpp

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    unordered_map<string, int> cnt;
    unordered_map<string, bool> in_res;
    vector<string> res;

    while (n--) {
        string topic;
        cin >> topic;
        cnt[topic]++;
        if (cnt[topic] >= 3 && !in_res[topic]) {
            res.push_back(topic);
            in_res[topic] = true;
        }
    }

    cout << res.size() << endl;
    for (const auto& topic : res) {
        cout << topic << endl;
    }
    return 0;
}

🍓 02.LYA 的游戏之旅

问题描述

LYA 是一位热爱游戏的少女。她有 $n$ 个游戏，每个游戏都有对应的游玩时间 $t_i$、体力消耗 $h_i$ 和快乐值 $a_i$。

现在 LYA 想要制定一个游戏计划，使得在总游玩时间不超过 $T$ 且总体力消耗不超过 $H$ 的前提下，获得尽可能多的快乐值。

请你帮助 LYA 计算，她最多可以获得多少快乐值。

输入格式

第一行输入三个正整数 $n,T,H$，分别代表游戏数量、游玩时间限制和体力限制。

接下来的 $n$ 行，每行输入三个正整数 $t_i,h_i,a_i$，分别代表第 $i$ 个游戏的游玩时间、体力消耗和快乐值。

输出格式

输出一个整数，代表 LYA 最多可以获得的快乐值。

样例输入

4 10 15
1 7 5
5 4 6
3 8 1
10 5 7

样例输出

11

数据范围

• $1\le n\le 50$
• $1\le T,H\le 500$
• $1\le t_i,h_i\le 30$
• $1\le a_i\le 10^9$

题解

本题可以使用二维动态规划来解决。定义状态 $f[i][j]$ 表示在游玩时间不超过 $i$，体力消耗不超过 $j$ 的情况下，可以获得的最大快乐值。

状态转移方程为：

$$f[i][j]=\max (f[i][j],f[i-t_k][j-h_k]+a_k)$$

其中 $k$ 表示当前正在考虑的游戏编号，$t_k,h_k,a_k$ 分别表示第 $k$ 个游戏的游玩时间、体力消耗和快乐值。

最终答案即为 $f[T][H]$。

时间复杂度为 $O(nTH)$，空间复杂度为 $O(TH)$。

参考代码

• Python

def max_happiness(n, T, H, games):
    f = [[0] * (H + 1) for _ in range(T + 1)]
    for t, h, a in games:
        for i in range(T, t - 1, -1):
            for j in range(H, h - 1, -1):
                f[i][j] = max(f[i][j], f[i - t][j - h] + a)
    return f[T][H]

n, T, H = map(int, input().split())
games = [tuple(map(int, input().split())) for _ in range(n)]
print(max_happiness(n, T, H, games))

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int T = sc.nextInt();
        int H = sc.nextInt();
        int[][] games = new int[n][3];
        for (int i = 0; i < n; ++i) {
            games[i][0] = sc.nextInt();
            games[i][1] = sc.nextInt();
            games[i][2] = sc.nextInt();
        }
        System.out.println(maxHappiness(n, T, H, games));
    }

    private static long maxHappiness(int n, int T, int H, int[][] games) {
        long[][] f = new long[T + 1][H + 1];
        for (int[] game : games) {
            int t = game[0], h = game[1], a = game[2];
            for (int i = T; i >= t; --i) {
                for (int j = H; j >= h; --j) {
                    f[i][j] = Math.max(f[i][j], f[i - t][j - h] + a);
                }
            }
        }
        return f[T][H];
    }
}

• Cpp

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

using LL = long long;

LL max_happiness(int n, int T, int H, vector<vector<int>>& games) {
    vector<vector<LL>> f(T + 1, vector<LL>(H + 1));
    for (auto& game : games) {
        int t = game[0], h = game[1], a = game[2];
        for (int i = T; i >= t; --i) {
            for (int j = H; j >= h; --j) {
                f[i][j] = max(f[i][j], f[i - t][j - h] + a);
            }
        }
    }
    return f[T][H];
}

int main() {
    int n, T, H;
    cin >> n >> T >> H;
    vector<vector<int>> games(n, vector<int>(3));
    for (int i = 0; i < n; ++i) {
        cin >> games[i][0] >> games[i][1] >> games[i][2];
    }
    cout << max_happiness(n, T, H, games) << endl;
    return 0;
}

🍏 03.LYA 的魔法花园

问题描述

LYA 是一位热爱园艺的魔法师。她的花园里有一棵特殊的魔法树，树上的每个节点都有一个魔力值。最初，所有节点都是白色的。

LYA 发现，每次可以选择两个相邻的白色节点，如果它们的魔力值之和是一个质数，就可以将其中一个节点染成紫色。LYA 想知道，最多可以将多少个节点染成紫色。

现在给定这棵魔法树的节点数 $n$，每个节点的魔力值 $a_i$，以及 $n-1$ 条边的信息，请你帮助 LYA 计算最多可以染成紫色的节点数量。

输入格式

第一行输入一个正整数 $n$，表示魔法树的节点数。

第二行输入 $n$ 个正整数 $a_1,a_2,\dots ,a_n$，表示每个节点的魔力值。

接下来 $n-1$ 行，每行输入两个正整数 $u,v$，表示节点 $u$ 和节点 $v$ 之间有一条边相连。

输出格式

输出一个整数，表示最多可以染成紫色的节点数量。

样例输入

4
1 2 3 4
1 2
2 3
3 4

样例输出

3

数据范围

• $1\le n\le 10^5$
• $1\le a_i\le 10^5$
• $1\le u,v\le n$

题解

本题可以使用树形 DP 求解。对于每个节点，我们维护两个状态：

• $f[i][0]$：以节点 $i$ 为根的子树中，不染节点 $i$ 的情况下，最多可以染成紫色的节点数量。
• $f[i][1]$：以节点 $i$ 为根的子树中，染节点 $i$ 的情况下，最多可以染成紫色的节点数量。

对于每个节点 $i$，我们枚举其所有子节点 $j$，并计算：

• 如果不染节点 $i$，则 $f[i][0]={\sum }_j\max (f[j][0],f[j][1]+check(a[i]+a[j]))$
• 如果染节点 $i$，则 $f[i][1]={\sum }_j(check(a[i]+a[j])+f[j][0])$

其中 $check(x)$ 表示判断 $x$ 是否为质数，如果是质数则返回 $1$，否则返回 $0$。

最后，答案即为 $\max (f[root][0],f[root][1])$。

总时间复杂度为 $O(n\sqrt{MAX})$，其中 $MAX$ 表示魔力值的最大值。

参考代码

• Python

from typing import List

class Solution:
    def maxPurpleNodes(self, n: int, a: List[int], edges: List[List[int]]) -> int:
        def is_prime(x: int) -> bool:
            if x < 2:
                return False
            i = 2
            while i * i <= x:
                if x % i == 0:
                    return False
                i += 1
            return True

        def dfs(curr: int, parent: int) -> int:
            for child in adj[curr]:
                if child == parent:
                    continue
                dfs(child, curr)
                f[curr][0] += max(f[child][0], f[child][1] + is_prime(a[curr] + a[child]))
                f[curr][1] += is_prime(a[curr] + a[child]) + f[child][0]
            return max(f[curr][0], f[curr][1])

        adj = [[] for _ in range(n + 1)]
        for u, v in edges:
            adj[u].append(v)
            adj[v].append(u)

        f = [[0, 0] for _ in range(n + 1)]
        return dfs(1, 0)

• Java

import java.util.*;

class Solution {
    private List<List<Integer>> adj;
    private int[] a;
    private int[][] f;

    public int maxPurpleNodes(int n, int[] a, int[][] edges) {
        this.a = a;
        adj = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }
        for (int[] edge : edges) {
            int u = edge[0], v = edge[1];
            adj.get(u).add(v);
            adj.get(v).add(u);
        }

        f = new int[n + 1][2];
        return dfs(1, 0);
    }

    private int dfs(int curr, int parent) {
        for (int child : adj.get(curr)) {
            if (child == parent) {
                continue;
            }
            dfs(child, curr);
            f[curr][0] += Math.max(f[child][0], f[child][1] + isPrime(a[curr - 1] + a[child - 1]));
            f[curr][1] += isPrime(a[curr - 1] + a[child - 1]) + f[child][0];
        }
        return Math.max(f[curr][0], f[curr][1]);
    }

    private int isPrime(int x) {
        if (x < 2) {
            return 0;
        }
        for (int i = 2; i * i <= x; i++) {
            if (x % i == 0) {
                return 0;
            }
        }
        return 1;
    }
}

• Cpp

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> adj[100005];
int n, a[100005];
int f[100005][2];

int isPrime(int x) {
    if (x < 2) return 0;
    for (int i = 2; i * i <= x; ++i) {
        if (x % i == 0) return 0;
    }
    return 1;
}

int dfs(int curr, int parent) {
    for (int child : adj[curr]) {
        if (parent == child) continue;
        dfs(child, curr);
        f[curr][0] += max(f[child][0], f[child][1] + isPrime(a[curr] + a[child]));
        f[curr][1] += isPrime(a[curr] + a[child]) + f[child][0];
    }
    return max(f[curr][0], f[curr][1]);     
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    for (int i = 1; i < n; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    cout << dfs(1, 0) << endl;
    return 0;
}

🎀 写在最后

🛖 这里介绍一下咱们的笔试打卡小屋

✨ 打卡小屋旨在陪伴大家，养成每日学习的好习惯。在这里，你可以：

• 🤝 与备战笔试的小伙伴相识，找到志同道合的学习小组
• 📝 通过写题解，巩固做题思路，养成良好的记录习惯
• 💡 系统掌握常考算法和数据结构，了解互联网笔试难度
• 🎁 坚持打卡，获得丰厚奖励，激励自己持之以恒

🥰 打卡奖励

打卡时长	奖励内容
7天	任选一家最新互联网笔试真题 x 1 (价值29.9r)
14天	任选一家最新互联网笔试真题 x 3 + 笔试面试经验贴
21天	任选一家最新互联网笔试真题 x 5 + 清隆三语言算法模版
28天	最新互联网大厂笔试真题汇总(价值199r) + 华为OD机试训练营 (价值89r)

7天打卡即可值回票价，心动不如行动！

🕰 每日学习安排

小屋将在每日上午发放打卡题目，包括：

• 一道算法模版题，帮助大家掌握常用算法套路
• 根据算法模版，精选一道对应的大厂笔试真题，巩固算法应用

让我们一起直击笔试重点，攻克常考题型！

📖 打卡小屋涉及题型

小屋从零基础出发，涵盖笔试常考知识点：

基础算法

• 自定义排序
• 二分
• 前缀和
• 差分
• 双指针

基础数据结构

• 栈 & 单调栈
• 队列 & 单调队列
• 并查集
• 优先队列(堆)

搜索

• DFS & BFS 基础应用
• 树的遍历
• 基础图论

动态规划 & 贪心 & 数论

• 快速幂
• 组合数
• 质数 & 因数
• 位运算
• 基础动态规划
• 常见贪心