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

💻 ACM金牌团队🏅️ | 多次AK大厂笔试 ｜ 大厂实习经历

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

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

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

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

🍄 题面描述等均已改编，如果和你笔试题看到的题面描述不一样请理解，做法和题目本质基本不变。

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

🌈 京东秋招笔试，来啦！！！

🍥 本次三题难度不大，前两题比较容易，第三题需要离散化，笔试中出现过很多次了

1️⃣ 根据对应的输入贪心模拟即可

2️⃣ 思维+模拟题，分析出来三个图的面积分别由什么构成，难度不大

3️⃣ 离散化+最短路，本题需要看出离散化这个知识点

🪴 01.LYA的秘密花园 评测链接🔗

问题描述

LYA是一位热爱园艺的年轻女孩。她在自家后院建造了一个秘密花园，里面种植了各种珍稀植物。为了保护这些植物不被偷盗，LYA设计了一个特殊的密码锁系统。

这个系统需要输入一个正整数作为密码。LYA每天都会更换密码，并给她的好朋友K小姐一些提示。每个提示包含两个数字 和 ，表示当天的密码与 的差的绝对值不超过 。

今天，K小姐收到了 个这样的提示。她想知道，根据这些提示，最大可能的密码是多少。你能帮助K小姐找出这个数字吗？

输入格式

第一行包含一个整数 ，表示提示的数量。

接下来的 行，每行包含两个整数 和 ，表示一个提示。

输出格式

输出一个整数，表示满足所有提示的最大可能密码。如果不存在满足所有提示的密码，输出 。

样例输入

3
3 3
2 5
5 3

样例输出

6

样例输入

3
1 1
2 2
3 3

样例输出

2

数据范围

题解

贪心

本质上是在寻找多个区间的交集的最大值。

每个提示 实际上定义了一个区间 ，需要找出所有这些区间的交集的最大值。

解题思路如下：

1. 初始化答案区间为 。

2. 对于每个提示 ，更新答案区间：

   • 区间左端点 = max(当前左端点, )
   • 区间右端点 = min(当前右端点, )

3. 在处理完所有提示后，如果左端点大于右端点，说明不存在满足所有提示的密码，返回 。

4. 否则，右端点就是要找的最大可能密码。

参考代码

• Python

# 读取提示的数量
Q = int(input())

# 初始化答案区间
left, right = 0, 10**9

# 处理每个提示
for _ in range(Q):
    # 读取提示
    M, D = map(int, input().split())
    
    # 更新区间
    left = max(left, M - D)
    right = min(right, M + D)

# 检查是否存在满足所有提示的密码
if left > right:
    print(-1)
else:
    print(right)

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取提示的数量
        int Q = scanner.nextInt();
        
        // 初始化答案区间
        long left = 0, right = 1_000_000_000;
        
        // 处理每个提示
        for (int i = 0; i < Q; i++) {
            // 读取提示
            long M = scanner.nextLong();
            long D = scanner.nextLong();
            
            // 更新区间
            left = Math.max(left, M - D);
            right = Math.min(right, M + D);
        }
        
        // 检查是否存在满足所有提示的密码
        if (left > right) {
            System.out.println(-1);
        } else {
            System.out.println(right);
        }
        
        scanner.close();
    }
}

• Cpp

#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int Q;
    cin >> Q;  // 读取提示的数量

    long long left = 0, right = 1e9;  // 初始化答案区间

    // 处理每个提示
    for (int i = 0; i < Q; i++) {
        long long M, D;
        cin >> M >> D;  // 读取提示

        // 更新区间
        left = max(left, M - D);
        right = min(right, M + D);
    }

    // 检查是否存在满足所有提示的密码
    if (left > right) {
        cout << -1 << endl;
    } else {
        cout << right << endl;
    }

    return 0;
}

🧸 02.立体花园设计 评测链接🔗

问题描述

K小姐是一位著名的景观设计师，她正在为一个新的立体花园项目设计布局。这个花园由一个矩形网格组成，每个格子里可以堆叠不同高度的花盆。K小姐想要知道从不同角度看这个花园时的视觉效果。

具体来说，K小姐需要计算从正面、左侧和顶部观察花园时看到的面积。每个花盆的底面积为1平方单位，高度为1单位。

输入格式

第一行包含两个整数 和 ，分别表示花园的行数和列数。

接下来的 行，每行包含 个整数 ，表示第 行第 列格子中堆叠的花盆数量。

输出格式

输出一行，包含三个整数，分别表示从正面、左侧和顶部观察时看到的面积。

样例输入

2 3
3 3 2
3 2 1

样例输出

8 6 6

数据范围

题解

枚举+思维

1. 正面观察： 从正面看，只能看到每一列中最高的花盆。因此，需要找出每一列的最大值，然后将这些最大值相加。

2. 左侧观察： 类似地，从左侧看，只能看到每一行中最高的花盆。需要找出每一行的最大值，然后将这些最大值相加。

3. 顶部观察： 从顶部看，能看到所有非空的格子。因此，只需要计算有花盆的格子数量。

参考代码

• Python

  # 读取输入
  n, m = map(int, input().split())
  garden = [list(map(int, input().split())) for _ in range(n)]

  # 初始化结果变量
  front_view = 0  # 正面观察面积
  side_view = 0   # 左侧观察面积
  top_view = 0    # 顶部观察面积

  # 初始化每列的最大高度
  col_max = [0] * m

  # 遍历花园
  for i in range(n):
      row_max = 0  # 当前行的最大高度
      for j in range(m):
          height = garden[i][j]
          if height > 0:
              top_view += 1  # 顶部可见
          row_max = max(row_max, height)  # 更新行最大值
          col_max[j] = max(col_max[j], height)  # 更新列最大值
      side_view += row_max  # 累加左侧可见面积

  # 计算正面可见面积
  front_view = sum(col_max)

  # 输出结果
  print(front_view, side_view, top_view)

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取输入
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] garden = new int[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                garden[i][j] = scanner.nextInt();
            }
        }
        
        // 初始化结果变量
        int frontView = 0;  // 正面观察面积
        int sideView = 0;   // 左侧观察面积
        int topView = 0;    // 顶部观察面积
        
        // 初始化每列的最大高度
        int[] colMax = new int[m];
        
        // 遍历花园
        for (int i = 0; i < n; i++) {
            int rowMax = 0;  // 当前行的最大高度
            for (int j = 0; j < m; j++) {
                int height = garden[i][j];
                if (height > 0) {
                    topView++;  // 顶部可见
                }
                rowMax = Math.max(rowMax, height);  // 更新行最大值
                colMax[j] = Math.max(colMax[j], height);  // 更新列最大值
            }
            sideView += rowMax;  // 累加左侧可见面积
        }
        
        // 计算正面可见面积
        for (int max : colMax) {
            frontView += max;
        }
        
        // 输出结果
        System.out.println(frontView + " " + sideView + " " + topView);
        
        scanner.close();
    }
}

• Cpp

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    
    // 读取花园布局
    vector<vector<int>> garden(n, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> garden[i][j];
        }
    }
    
    // 初始化结果变量
    int front_view = 0;  // 正面观察面积
    int side_view = 0;   // 左侧观察面积
    int top_view = 0;    // 顶部观察面积
    
    // 初始化每列的最大高度
    vector<int> col_max(m, 0);
    
    // 遍历花园
    for (int i = 0; i < n; ++i) {
        int row_max = 0;  // 当前