笔试时间：2025年9月12日

往年笔试合集：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

题目：你正在参与股票交易，但需遵守以下规则：

1. 每次卖出股票后，必须经过k天（不包括卖出当天）的冷却期才能再次买入
2. 最多只能持有一股股票
3. 可以多次交易，但每次交易（买入和卖出）必须完整
4. 给定股票每日价格数组prices和冷却天数k，求你能获得的最大利润

输入描述

• 输入价格数组：prices = [x,y,z,u,v,w]，每个元素代表每天的价格
• 冷却天数：k

输出描述

能获得的最大利润（int）

样例输入

[1, 3, 5, 2, 6, 4], 1

样例输出

6

参考题解

解题思路：使用动态规划，定义两个状态：

• dp[i][0]：第i天不持有股票的最大利润
• dp[i][1]：第i天持有股票的最大利润 考虑冷却期k的约束，买入时需要从k+1天前的不持有状态转移

C++：

class Solution {
public:
    int maxProfit(vector<int>& prices, int k) {
        int n = prices.size();
        if (n <= 1) return 0;
        
        vector<vector<int>> dp(n, vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            if (i - k - 1 < 0) {
                dp[i][1] = max(dp[i-1][1], -prices[i]);
            } else {
                dp[i][1] = max(dp[i-1][1], dp[i - k - 1][0] - prices[i]);
            }
        }
        
        return dp[n-1][0];
    }
};

Java：

public class Solution {
    public int maxProfit(int[] prices, int k) {
        int n = prices.length;
        if (n <= 1) return 0;
        
        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        
        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
            if (i - k - 1 < 0) {
                dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
            } else {
                dp[i][1] = Math.max(dp[i-1][1], dp[i - k - 1][0] - prices[i]);
            }
        }
        
        return dp[n-1][0];
    }
}

Python：

class Solution:
    def maxProfit(self, prices: List[int], k: int) -> int:
        n = len(prices)
        if n <= 1:
            return 0
        
        dp = [[0, 0] for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        
        for i in range(1, n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            if i - k - 1 < 0:
                dp[i][1] = max(dp[i-1][1], -prices[i])
            else:
                dp[i][1] = max(dp[i-1][1], dp[i - k - 1][0] - prices[i])
        
        return dp[n-1][0]

第二题

某公司发布了两款新产品，在旗舰店开放了新品体验活动。需要开发一个智能排队系统的核心算法，精确预估一位同时预约了两款产品的消费者所需花费的总时间。

系统规则：

1. 动态优先级排序（三级规则）： 第一优先级：预约优先级（1-10，数字越小优先级越高）第二优先级：预计体验时间（时间越短优先级越高）第三优先级：预约次序（序号越小优先级越高）
2. 过号处理规则：未到达时视为过号，需等待当前及后续两位消费者完成
3. 跨区体验逻辑：优先去最先轮到的体验区

输入描述

• queueA：二维整数数组，A产品体验区排队信息，每个子数组[priority, duration]
• queueB：格式同queueA，B产品体验区排队信息
• targetConsumerIds：长度为2的数组[id_a, id_b]，目标消费者在两个队列中的索引

输出描述

一个整数，表示目标消费者完成所有体验所需的总时间

样例输入

[[2,10]], [[3,15]], [0,0]

样例输出

25

参考题解

解题思路：通过事件驱动模拟，跟踪每个体验区和消费者状态，根据优先级规则动态选择下一个消费者，处理过号情况，计算目标消费者完成两个体验的总时间。

Java：

import java.util.*;

public class Solution {
    public int calculateTotalTime(int[][] queueA, int[][] queueB, int[] targetConsumerIds) {
        int n = queueA.length;
        int[] priorityA = new int[n];
        int[] durationA = new int[n];
        int[] priorityB = new int[n];
        int[] durationB = new int[n];
        for (int i = 0; i < n; i++) {
            priorityA[i] = queueA[i][0];
            durationA[i] = queueA[i][1];
            priorityB[i] = queueB[i][0];
            durationB[i] = queueB[i][1];
        }

        int targetA = targetConsumerIds[0];
        int targetB = targetConsumerIds[1];

        int[] startA = new int[n];
        int[] endA = new int[n];
        int[] startB = new int[n];
        int[] endB = new int[n];
        Arrays.fill(startA, -1);
        Arrays.fill(startB, -1);
        Arrays.fill(endA, -1);
        Arrays.fill(endB, -1);

        boolean[] doneA = new boolean[n];
        boolean[] doneB = new boolean[n];
        boolean[] arrivedA = new boolean[n];
        boolean[] arrivedB = new boolean[n];
        Arrays.fill(arrivedA, true);
        Arrays.fill(arrivedB, true);

        int[] waitCountA = new int[n];
        int[] waitCountB = new int[n];

        int currentTimeA = 0;
        int currentTimeB = 0;
        int currentConsumerA = -1;
        int currentConsumerB = -1;
        int endTimeA = -1;
        int endTimeB = -1;

        while (!doneA[targetA] || !doneB[targetB]) {
            if (currentConsumerA == -1 || currentTimeA >= endTimeA) {
                if (currentConsumerA != -1) {
                    int consumer = currentConsumerA;
                    endA[consumer] = endTimeA;
                    doneA[consumer] = true;
                    arrivedB[consumer] = true;
                    if (startB[consumer] != -1 && startB[consumer] < endTimeA) {
                        waitCountB[consumer] = 3;
                    }
                    currentC