【2024-03-30】b站（bilibili）春招笔试编程题解析

恭喜发现宝藏！搜索公众号【TechGuide】回复公司名，解锁更多新鲜好文和互联网大厂的笔经面经。
作者@TechGuide【全网同名】

订阅专栏： 【专享版】2024最新大厂笔试真题解析，错过必后悔的宝藏资源！

第一题：池化

题目描述

小盖在学习热门话题深度学习时，梦想早日毕业的小盖受常用的卷积神经网络(CNN)的池化操作启发，创建了自己的池化并应用于在图像处理中。

下面描述了应用小盖池化一次的过程，假设给定一个8* 8的矩阵。

1.将矩阵分成大小为22的子矩阵。
2.在每个2 2的子矩阵中只留下第二大的数字。在这里，当子矩阵的四个元素为a4≤a3 ≤a2≤a1时，第二大数为元素a2。

3.重复2的过程，矩阵的大小不断缩小。现在小盖想知道当N * N矩阵通过重复应用池化操作，最终变成1 * 1时，留下的数是多少?

输入描述

第—行给出N。且N总是2的幂。($N=2^K,1<k<10$)< p=“”></k<10$)<>

接下来的N行，依次给出每行的N个元素。

矩阵的每个元素都是大于等于―10000且小于等于10000的整数。

2≤N≤ 1024

输出描述

输出最后剩余的数字。

样例

输入

4
-6 -8 7 -4
-5 -5 14 11
11 11 -1 -1
4 9 -2 -4

输出

11

样例说明

当矩阵变成1*1时,留下的数是11

思路

模拟CNN的池化操作，挺有创意的题目（21年也考过。。），难度不大，简单说下思路吧，递归地将矩阵分割并找出每个子区域的第二大元素，最终得到了整个矩阵的第二大元素。

代码

Python版本

def pool_matrix(N, matrix):
    # 定义池化函数
    def pool_helper(pool_func, left, top, right, bottom):
        n = right - left + 1
        # 如果当前区域只有一个元素，直接返回该元素的值
        if n == 1:
            return matrix[left-1][top-1]
        # 否则，递归对四个子区域进行池化操作
        sub_matrix = [
            pool_func(pool_func, left, top, left + n // 2 - 1, top + n // 2 - 1),
            pool_func(pool_func, left, top + n // 2, left + n // 2 - 1, bottom),
            pool_func(pool_func, left + n // 2, top, right, top + n // 2 - 1),
            pool_func(pool_func, left + n // 2, top + n // 2, right, bottom)
        ]
        # 对四个子区域的第二大元素进行排序，取第二大元素作为当前区域的第二大元素，并返回
        sub_matrix.sort(reverse=True)
        return sub_matrix[1]
    
    # 调用池化函数，传入整个矩阵的范围进行池化操作，并返回结果
    return pool_helper(pool_helper, 0, 0, N-1, N-1)

N = int(input())
matrix = []
for _ in range(N):
    matrix.append(list(map(int, input().split())))

# 调用池化函数，并输出最终结果
result = pool_matrix(N, matrix)
print(result)
# vx公众号关注TechGuide，专业生产offer收割机，代码可能需要少量调试。

Java版本

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt(); // 读取矩阵的大小N
        int[][] matrix = new int[N][N]; // 创建矩阵

        // 读取矩阵的元素
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                matrix[i][j] = scanner.nextInt();
            }
        }

        // 调用池化函数，并输出最终结果
        int result = poolMatrix(N, matrix);
        System.out.println(result);
    }

    // 池化函数
    public static int poolMatrix(int N, int[][] matrix) {
        // 定义池化函数
        PoolHelper poolHelper = (self, left, top, right, bottom) -> {
            int n = right - left + 1;
            // 如果当前区域只有一个元素，直接返回该元素的值
            if (n == 1) {
                return matrix[left-1][top-1];
            }
            // 否则，递归对四个子区域进行池化操作
            int[] subMatrix = {
                self.poolFunction(self, left, top, left + n / 2 - 1, top + n / 2 - 1),
                self.poolFunction(self, left, top + n / 2, left + n / 2 - 1, bottom),
                self.poolFunction(self, left + n / 2, top, right, top + n / 2 - 1),
                self.poolFunction(self, left + n / 2, top + n / 2, right, bottom)
            };
            // 对四个子区域的第二大元素进行排序，取第二大元素作为当前区域的第二大元素，并返回
            Arrays.sort(subMatrix);
            return subMatrix[2];
        };

        // 调用池化函数，传入整个矩阵的范围进行池化操作，并返回结果
        return poolHelper.poolFunction(poolHelper, 0, 0, N-1, N-1);
    }

    
    interface PoolHelper {
        int poolFunction(PoolHelper self, int left, int top, int right, int bottom);
    }
}
// vx公众号关注TechGuide，专业生产offer收割机，代码可能需要少量调试。