✅ 春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：90分钟/套）
• 对照解析查漏补缺
• 配套练习题库

互联网必备刷题宝典🔗

📢 美团技术岗笔试重要信息速览

⏰ 笔试时间安排

• 常规场次：每周六交替进行
  • 上午场 10:00~11:30
  • 晚间场 19:00~20:30
• 通知时间：每周四/五通过邮箱发送考试链接

🧩 笔试题型分布

⚙️ 考试设置要点

• 考试平台：牛客网（ACM模式）
• 监考要求：
  • 必须开启笔记本前置摄像头
  • 禁止使用手机（需小程序锁定）
  • 允许使用本地IDE
• 编程规范：
  • 严格遵循输入输出格式
  • 注意时间复杂度控制（通常1s对应1e8次运算）

📚 笔试经验贴

（所有展示题面均已进行改编处理，保留核心考点）

本题库收录整理自：

1. 互联网公开的笔试真题回忆版（经网友投稿）
2. 各大技术社区公开讨论的经典题型
3. 历年校招考生提供的解题思路

🔍 题库特点：

• 100%真实笔试场景还原
• 包含高频考点题型
• 提供多语言实现参考
• 持续更新2024届最新真题

⚠️ 注意事项：

1. 所有题目均来自公开渠道，已进行改编脱敏处理
2. 实际笔试可能出现题型变化，请以官方通知为准

🚀 春招备战指南

金三银四求职季即将到来！这里整理了最新美团真题及解析，助你快速掌握笔试套路。建议重点突破以下题型：

1. 数组/字符串操作
2. 树形结构应用
3. 贪心/动态规划
4. 区间合并问题

（👇 下附最新笔试真题及详细解析 👇）

真题详解（改编版）

第一题：好矩阵

题目内容

小基定义一个矩阵是"好矩阵"，当且仅当该矩阵所有元素都相同。现在小基拿到了一个矩阵，她想知道该矩阵有多少个 的子矩阵是好矩阵？

输入描述

第一行输入两个正整数 和 ，代表矩阵的行数和列数。 接下来的 行，每行输入 个正整数 ，代表小基拿到的矩阵。

输出描述

好子矩阵的数量。

样例1

输入：

3 3
1 2 1
1 1 1
1 1 3

输出：

1

说明：只有左下角一个好子矩阵。

题解

这是一道简单的模拟题。只需要枚举每个可能的 子矩阵的左上角位置，然后判断这个子矩阵的四个元素是否相等即可。

时间复杂度： 空间复杂度：

三语言参考代码

• C++

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> g(n, vector<int>(m));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> g[i][j];
        }
    }
    int ans = 0;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < m - 1; j++) {
            if (g[i][j] == g[i + 1][j] && g[i + 1][j] == g[i][j + 1] && g[i][j + 1] == g[i + 1][j + 1]) {
                ans++;
            }
        }
    }
    cout << ans << endl;
    return 0;
}

• Python

n, m = map(int, input().split())
g = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n - 1):
    for j in range(m - 1):
        if g[i][j] == g[i + 1][j] and g[i + 1][j] == g[i][j + 1] and g[i][j + 1] == g[i + 1][j + 1]:
            ans += 1
print(ans)

• 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[][] g = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                g[i][j] = scanner.nextInt();
            }
        }
        int ans = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < m - 1; j++) {
                if (g[i][j] == g[i + 1][j] && g[i + 1][j] == g[i][j + 1] && g[i][j + 1] == g[i + 1][j + 1]) {
                    ans++;
                }
            }
        }
        System.out.println(ans);
        scanner.close();
    }
}

第二题：最多零的数组

题目内容

小基拿到了一个数组，她可以进行最多 次操作，每次操作任选一个元素加 1 或者减 1。小基希望最终 0 的数量尽可能多。你能帮帮她吗？

输入描述

第一行输入 2 个正整数 ，代表数组大小和小基的操作次数。 第二行输入 个整数 ，代表小基拿到的数组。

输出描述

一个整数，代表最终 0 的数量的最大值。

样例1

输入：

4 5
-2 3 -2 9

输出：

2

说明：对第二个元素操作 3 次减 1，对第三个元素操作 2 次加 1，这样数组变成 [-2,0,0,9]。

题解

这道题的关键是贪心思想。对于每个数，将其变成 0 需要的操作次数就是其绝对值。因此，应该优先选择绝对值小的数进行操作。

时间复杂度： 空间复杂度：

三语言参考代码

• C++

#include<bits/stdc++.h>
using namespace std;
const int N = 1E5 + 10;
typedef long long ll;
ll a[N], n, k;

int main() {
    cin >> n >> k;
    for(int i = 0; i < n; i++) {
        cin >> a[i];
        a[i] = abs(a[i]);
    }
    sort(a, a + n);
    int cnt = 0;
    for(int i = 0; i < n; i++) {
        if(k < a[i]) break;
        k -= a[i];
        cnt++;
    }
    cout << cnt << endl;
    return 0;
}

• Python

n, k = map(int, input().split())
nums = list(map(int, input().split()))
nums = sorted(map(abs, nums))
count = 0
for num in nums:
    if k >= num:
        k -= num
        count += 1
    else:
        break
print(count)

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong(), k = in.nextLong();
        Long[] arr = new Long[(int)n];
        for(int i = 0; i < n; i++) arr[i] = in.nextLong();
        Arrays.sort(arr, (Long a, Long b) -> Long.compare(Math.abs(a), Math.abs(b)));
        int res = 0;
        for(int i = 0; i < n; i++) {
            if(k >= Math.abs(arr[i])) {
                k -= Math.abs(arr[i]);
                res++;
            }
            else break;
        }
        System.out.println(res);
    }
}

第三题：红黑树

题目内容

小基有一棵有 个节点的树，根节点为 1 号节点，树的每个节点是红色或者黑色，她想知道有多少节点的子树中同时包含红点和黑点。

输入描述

第一行输入一个整数 表示节点数量。 第二行输入一个长度为 的字符串 表示节点的颜色，第 个节点的颜色为 ，若 为'B'表示节点的颜色为黑色，若 为'R'则表示节点的颜色为红色。 接下来 行，每行输入两个整数 表示树上的边。

输出描述

输出一个整数表示答案。

样例1

输入：

3
BRB
1 2
2 3

输出：

2

题解

这是一道树形 DFS 问题。对于每个节点，需要统计其子树中红色和黑色节点的数量。如果两种颜色的节点数量都大于 0，则这个子树满足条件。

时间复杂度： 空间复杂度：

三语言参考代码

• C++

#include<bits/stdc++.h>
using namespace std;
const int N = 1E5 + 10;
int n, res;
string s;
vector<int> g[N];

vector<int> dfs(int u, int fa) {
    vector<int> color(2, 0);
    if(s[u] == 'B') color[0]++;
    else color[1]++;
    for(int &x : g[u]) {
        if(x == fa) continue;
        auto v = dfs(x, u);
        color[0] += v[0];
        color[1] += v[1];
    }
    if(color[0] > 0 && color[1] > 0) res++;
    return color;
}

int main() {
    cin >> n >> s;
    s = " " + s;
    for(int i = 1; i < n; i++) {
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(1, 0);
    cout << res << endl;
    return 0;
}

• Python

import sys
sys.setrecursionlimit(200000)

n = int(input())
color = input()
adj = [[] for _ in range(n)]
for _ in range(n-1):
    u, v = map(int, input().split())
    adj[u-1].append(v-1)

count = 0

def dfs(i):
    global count
    if len(adj[i]) == 0:
        return False
    flag = False
    for j in adj[i]:
        if dfs(j):
            flag = True
        else:
            if color[i] != color[j]:
                flag = True
    if flag:
        count += 1
    return flag

dfs(0)
print(count)

• Java

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

class Main {
    static int n;
    static Node[] nodes;
    static int res = 0;

    static int dfs(int nodeIndex, HashMap<Integer,Integer> visited) {
        visited.put(nodeIndex, 0);
        Node node = nodes[nodeIndex];
        boolean red = node.color == 'R';
        boolean black = node.color == 'B';
        
        for(int i : node.children.keySet()) {
            if(visited.get(i) != null) continue;
            int num = dfs(i, visited);
            if(num == 0) black = true;
            else if(num == 1) red = true;
            else {
                black = true;
                red = true;
            }
        }
        
        if(red && black) {
            res++;
            return 2;
        }
        return red ? 1 :