🍭 大家好这里是 春秋招笔试突围，一起备战大厂笔试

💻 ACM金牌团队🏅️ | 多次AK大厂笔试 ｜ 编程一对一辅导

✨ 本系列打算持续跟新 春秋招笔试题

👏 感谢大家的订阅➕ 和 喜欢💗 和 手里的小花花🌸

✨ 笔试合集传送们 -> 🧷春秋招笔试合集

🍒 本专栏已收集 50+ 套笔试题，笔试真题 会在第一时间跟新

🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力 💞！

🚠 4399 的笔试来辣！

🍥 4399目前来看，有很多套卷，根据网友的投稿以及反馈，保底至少有3套

1️⃣ 模拟题，主要考察对字符串的处理能力

2️⃣ leetcode原题，比较典的状态机DP

3️⃣ 是一道大模拟，代码量不少。

⛪️ 01.探险家

问题描述

LYA 是一位热爱冒险的探险家，她最近发现了一个神秘的古代遗迹。这个遗迹中有一个复杂的宝物系统，宝物可以分为两类：单独宝物和组合宝物。组合宝物可以包含其他单独宝物或组合宝物。每件宝物都有一个基础价值，而其最终价值取决于它在系统中的嵌套深度。LYA 需要计算出整个宝物系统的总价值。

输入格式

输入为一个字符串，表示宝物系统的结构。字符串中的数字表示单独宝物的基础价值，方括号 [] 表示组合宝物的开始和结束。

输出格式

输出为一个整数，表示整个宝物系统的总价值。

样例输入

[1,[4,[6]]]

样例输出

27

数据范围

• 输入字符串长度不超过 10000。
• 单个宝物的基础价值为不超过 1000 的正整数。
• 嵌套深度不超过 100。

题解

按照题意模拟

关键步骤如下：

1. 遍历字符串，用一个变量记录当前深度。
2. 遇到 [ 时，深度加 1。
3. 遇到 ] 时，深度减 1。
4. 遇到数字时，解析出完整的数字，并将其乘以当前深度加入总和。

参考代码

• Python

def calculate_treasure_value(treasure_system):
    total_value = 0
    depth = 0
    i = 0
    n = len(treasure_system)
    
    while i < n:
        if treasure_system[i] == '[':
            depth += 1
        elif treasure_system[i] == ']':
            depth -= 1
        elif treasure_system[i].isdigit():
            # 解析数字
            value = 0
            while i < n and treasure_system[i].isdigit():
                value = value * 10 + int(treasure_system[i])
                i += 1
            i -= 1  # 回退一步，因为外层循环会再次 +1
            # 计算价值并加入总和
            total_value += value * (depth)
        i += 1
    
    return total_value

# 读取输入
treasure_system = input().strip()

# 计算并输出结果
result = calculate_treasure_value(treasure_system)
print(result)

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String treasureSystem = scanner.nextLine().trim();
        int result = calculateTreasureValue(treasureSystem);
        System.out.println(result);
    }

    public static int calculateTreasureValue(String treasureSystem) {
        int totalValue = 0;
        int depth = 0;
        int i = 0;
        int n = treasureSystem.length();

        while (i < n) {
            char c = treasureSystem.charAt(i);
            if (c == '[') {
                depth++;
            } else if (c == ']') {
                depth--;
            } else if (Character.isDigit(c)) {
                // 解析数字
                int value = 0;
                while (i < n && Character.isDigit(treasureSystem.charAt(i))) {
                    value = value * 10 + (treasureSystem.charAt(i) - '0');
                    i++;
                }
                i--; // 回退一步，因为外层循环会再次 +1
                // 计算价值并加入总和
                totalValue += value * (depth);
            }
            i++;
        }

        return totalValue;
    }
}

• Cpp

#include <iostream>
#include <string>

using namespace std;

int calculateTreasureValue(const string& treasureSystem) {
    int totalValue = 0;
    int depth = 0;
    int n = treasureSystem.length();

    for (int i = 0; i < n; ++i) {
        if (treasureSystem[i] == '[') {
            ++depth;
        } else if (treasureSystem[i] == ']') {
            --depth;
        } else if (isdigit(treasureSystem[i])) {
            // 解析数字
            int value = 0;
            while (i < n && isdigit(treasureSystem[i])) {
                value = value * 10 + (treasureSystem[i] - '0');
                ++i;
            }
            --i; // 回退一步，因为外层循环会再次 +1
            // 计算价值并加入总和
            totalValue += value * (depth);
        }
    }

    return totalValue;
}

int main() {
    string treasureSystem;
    getline(cin, treasureSystem);

    int result = calculateTreasureValue(treasureSystem);
    cout << result << endl;

    return 0;
}

🥅 02.她的手镯

问题描述

LYA 是一位著名的珠宝设计师，她最近设计了一系列独特的手镯。这些手镯被摆放在一个圆形展示台上，每个手镯都有其独特的价值。然而，展示台的安保系统有一个特殊的设置：如果相邻的两个手镯同时被移动，警报就会响起。

作为一个珠宝鉴赏家，你想要在不触发警报的情况下，选择一些手镯来欣赏。你的目标是在不触发警报的前提下，选择价值总和最高的手镯组合。

请注意，由于展示台是圆形的，第一个手镯和最后一个手镯被视为相邻。

输入格式

输入为一个整数数组 ，其中 表示第 个手镯的价值。

输出格式

输出一个整数，表示在不触发警报的情况下可以选择的手镯的最大总价值。

样例输入

[2, 3, 2]

样例输出

3

数据范围

• 
• 

题解

力扣原题：LCR 090. 打家劫舍 II

这个问题可以通过动态规划来解决。

关键是要意识到，由于手镯是环形排列的，我们可以将问题转化为两个子问题：

1. 考虑不选第一个手镯，在剩下的手镯中选择最大价值。
2. 考虑不选最后一个手镯，在剩下的手镯中选择最大价值。

这两个子问题都可以用线性动态规划来解决，最后取两者的最大值即为答案。

对于每个子问题，我们可以定义状态 表示到第 个手镯为止能够获得的最大价值。状态转移方程为：

这个方程表示，对于第 个手镯，我们有两个选择：不选它（），或者选它并且不选前一个（）。

最终的答案是两个子问题结果的最大值。

参考代码

• Python

class Solution:
    def rob(self, nums: List[int]) -> int:
        def rob_line(arr):
            if not arr:
                return 0
            if len(arr) == 1:
                return arr[0]
            
            dp = [0] * len(arr)
            dp[0] = arr[0]
            dp[1] = max(arr[0], arr[1])
            
            for i in range(2, len(arr)):
                dp[i] = max(dp[i-1], dp[i-2] + arr[i])
            
            return dp[-1]
        
        if len(nums) == 1:
            return nums[0]
        
        # 考虑不选第一个和不选最后一个的情况
        return max(rob_line(nums[1:]), rob_line(nums[:-1]))

# 处理输入
nums = list(map(int, input().strip('[]').split(',')))

# 创建Solution实例并调用rob方法
solution = Solution()
result = solution.rob(nums)

# 输出结果
print(result)

• Java

import java.util.*;

class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        return Math.max(robLine(Arrays.copyOfRange(nums, 0, nums.length - 1)),
                        robLine(Arrays.copyOfRange(nums, 1, nums.length)));
    }
    
    private int robLine(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
        }
        
        return dp[nums.length - 1];
    }

    public static void main(String[]