✅ 秋招备战指南 ✅

💡 学习建议：

• 先尝试独立解题
• 对照解析查漏补缺

🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。

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

🌸 目前本专栏已经上线100+套真题改编解析，后续会持续更新的

春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗

题目一：密码矩阵解锁

1️⃣：找出序列中前三大数字和最大质数

2️⃣：构建2×2矩阵并计算行列式

3️⃣：输出逆矩阵或判断不可逆情况

难度：中等

这道题目结合了数学中的矩阵运算和质数判断算法。关键在于理解矩阵逆的计算公式，以及如何高效地从序列中提取所需的数字。通过一次遍历同时完成多个任务，实现了较优的时间复杂度。

题目二：魔法药水配制

1️⃣：使用动态规划记录每个位置的最优状态

2️⃣：对辅助材料排序并使用二分查找优化

3️⃣：状态转移时考虑保持原值或替换两种选择

难度：中等偏难

这道题目是经典的动态规划问题，需要在保证严格递增约束的前提下最小化操作次数。通过状态压缩和二分查找优化，可以有效控制时间和空间复杂度。解题的关键是正确设计状态转移方程。

01. 密码矩阵解锁

问题描述

小毛是一名密码学专家，他设计了一种特殊的矩阵密码系统。该系统需要从一串数字序列中提取关键信息来构建解锁矩阵。

具体规则如下：

• 从数字序列中找出前三大的数字 （满足 ）
• 找出序列中的最大质数 （可能与前三大数字重复）
• 用这四个数字按行优先顺序构成 矩阵：

如果该矩阵可逆（即行列式 ），则输出其逆矩阵；否则输出 。

输入格式

第一行包含一个正整数 ，表示数字序列的长度。

第二行包含 个整数，表示数字序列。

输出格式

如果矩阵可逆，输出逆矩阵的四个元素，格式为：

a11 a12
a21 a22

如果矩阵不可逆或序列中没有质数，输出 。

注意：对于浮点数输出，只要与标准答案的绝对误差不超过 即视为正确。

样例输入

6
7 3 11 4 2 5

4
4 6 8 10

样例输出

1.279070 -0.813953
-0.581395  1.279070

-1

样例	解释说明
样例1	前三大数字：；最大质数：；行列式 ，矩阵可逆
样例2	序列中没有质数，输出

数据范围

• 
• 序列中的数字

题解

这道题的核心是理解矩阵逆的计算和质数判断。

首先分析问题：我们需要从数字序列中提取四个关键数字来构建矩阵。这包括找到前三大数字和最大质数。

对于 矩阵 ，其逆矩阵为：

当行列式 时，矩阵不可逆。

算法步骤：

1. 读入序列，一次遍历找出前三大数字
2. 同时在遍历过程中找出最大质数（需要质数判断函数）
3. 检查是否存在质数，如果不存在直接输出
4. 计算行列式，如果为 则输出
5. 否则计算并输出逆矩阵的各个元素

质数判断使用试除法，时间复杂度 。整体算法时间复杂度为 ，其中 是数字的最大值。

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

def is_prime(x):
    # 判断是否为质数
    if x < 2:
        return False
    if x == 2:
        return True
    if x % 2 == 0:
        return False
    i = 3
    while i * i <= x:
        if x % i == 0:
            return False
        i += 2
    return True

def solve():
    n = int(input())
    nums = list(map(int, input().split()))
    
    # 初始化前三大数字
    top3 = [-float('inf')] * 3
    max_prime = None
    
    for num in nums:
        # 更新前三大数字
        if num > top3[0]:
            top3[2] = top3[1]
            top3[1] = top3[0]
            top3[0] = num
        elif num > top3[1]:
            top3[2] = top3[1]
            top3[1] = num
        elif num > top3[2]:
            top3[2] = num
        
        # 更新最大质数
        if is_prime(num):
            if max_prime is None or num > max_prime:
                max_prime = num
    
    # 检查是否有质数
    if max_prime is None:
        print(-1)
        return
    
    a, b, c, d = top3[0], top3[1], top3[2], max_prime
    det = a * d - b * c
    
    # 检查矩阵是否可逆
    if det == 0:
        print(-1)
        return
    
    # 输出逆矩阵
    print(f"{d/det:.6f} {-b/det:.6f}")
    print(f"{-c/det:.6f} {a/det:.6f}")

if __name__ == "__main__":
    solve()

• Cpp

#include <bits/stdc++.h>
using namespace std;

bool is_prime(long long x) {
    // 判断是否为质数
    if (x < 2) return false;
    if (x == 2) return true;
    if (x % 2 == 0) return false;
    for (long long i = 3; i * i <= x; i += 2) {
        if (x % i == 0) return false;
    }
    return true;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n;
    cin >> n;
    
    // 初始化前三大数字
    long long top3[3] = {LLONG_MIN, LLONG_MIN, LLONG_MIN};
    long long max_prime = LLONG_MIN;
    bool has_prime = false;
    
    for (int i = 0; i < n; i++) {
        long long num;
        cin >> num;
        
        // 更新前三大数字
        if (num > top3[0]) {
            top3[2] = top3[1];
            top3[1] = top3[0];
            top3[0] = num;
        } else if (num > top3[1]) {
            top3[2] = top3[1];
            top3[1] = num;
        } else if (num > top3[2]) {
            top3[2] = num;
        }
        
        // 更新最大质数
        if (is_prime(num)) {
            has_prime = true;
            if (num > max_prime) {
                max_prime = num;
            }
        }
    }
    
    // 检查是否有质数
    if (!has_prime) {
        cout << -1 << "\n";
        return 0;
    }
    
    long long a = top3[0], b = top3[1], c = top3[2], d = max_prime;
    long long det = a * d - b * c;
    
    // 检查矩阵是否可逆
    if (det == 0) {
        cout << -1 << "\n";
        return 0;
    }
    
    // 输出逆矩阵
    cout << fixed << setprecision(6);
    cout << (double)d / det << " " << (double)(-b) / det << "\n";
    cout << (double)(-c) / det << " " << (double)a / det << "\n";
    
    return 0;
}

• Java

import java.io.*;
import java.util.*;

public class Main {
    static boolean isPrime(long x) {
        // 判断是否为质数
        if (x < 2) return false;
        if (x == 2) return true;
        if (x % 2 == 0) return false;
        for (long i = 3; i * i <= x; i += 2) {
            if (x % i == 0) return false;
        }
        return true;
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        String[] nums = br.readLine().split(" ");
        
        // 初始化前三大数字
        long[] top3 = {Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE};
        long maxPrime = Long.MIN_VALUE;
        boolean hasPrime = false;
        
        for (int i = 0; i < n; i++) {
            long num = Long.parseLong(nums[i]);
            
            // 更新前三大数字
            if (num > top3[0]) {
                top3[2] = top3[1];
                top3[1] = top3[0];
                top3[0] = num;
            } else if (num > top3[1]) {
                top3[2] = top3[1];