✅ 春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：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
1 2 3

输出：

3

说明：选择第 个数 ，数组变成 。满足条件，代价是 。

题解

这道题的关键是理解每个数字变换的代价。对于一个数字：

• 偶数变奇数的最小代价为
• 奇数变偶数的最小代价也是

只需要枚举两种情况：

1. 全部变成奇数的代价
2. 全部变成偶数的代价

取两者的最小值即为答案。

时间复杂度：，其中 是数组长度。

代码参考

• C++

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

int main() {
    int len;
    cin >> len;
    vector<int> nums(len);
    
    for (int i = 0; i < len; i++) {
        cin >> nums[i];
    }
    
    long long cost[2] = {0, 0};
    
    for (int val : nums) {
        if (val % 2 == 0) {
            cost[0] += val + 1;
        } else {
            cost[1] += val + 1;
        }
    }
    
    cout << min(cost[0], cost[1]) << endl;
    return 0;
}

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int size = scan.nextInt();
        int[] arr = new int[size];

        for (int i = 0; i < size; i++) {
            arr[i] = scan.nextInt();
        }

        long[] res = {0, 0};
        for (int num : arr) {
            if (num % 2 == 0) {
                res[0] += num + 1;
            } else {
                res[1] += num + 1;
            }
        }

        System.out.println(Math.min(res[0], res[1]));
    }
}

• Python

n = int(input())
nums = list(map(int, input().split()))
cost = [0, 0]

for x in nums:
    if x % 2 == 0:
        cost[0] += x + 1
    else:
        cost[1] += x + 1

print(min(cost))

第二题：相似节点

题目内容

小基对于给定的由 个节点构成，根节点为 的有根树中，定义节点 和 是"相似节点"，当且仅当节点 的子点数量 与节点 的子点数量 相等。

输出"相似节点"的对数。

输入描述

每个测试文件均含多组测试数据。第一行输入一个整数 ()代表数据组数，每组测试数据描述如下：

第一行输入一个整数 ()代表节点数量。

此后 行，第 行输入两个整数 和 ()表示树上第 条边连接节点 和 。保证树联通，没有重边。

除此之外，保证所有的 之和不超过 。

输出描述

对于每一组测试数据，在一行上输出一个整数，代表图中"相似节点"的对数。

样例1

输入：

1
7
1 2
1 3
3 5
3 7
2 4 
2 6

输出：

9

题解

这道题的关键是统计每个节点的子节点数量，然后找出具有相同子节点数量的节点对。

解题步骤：

1. 建立树的邻接表表示
2. 统计每个节点的子节点数量
3. 用哈希表记录相同子节点数量的节点个数
4. 对于每个子节点数量，计算组合数 C(m,2)，即 m*(m-1)/2

时间复杂度：，其中 是节点数量。

代码参考

• C++

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

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        vector<vector<int>> g(n);
        
        for (int i = 0; i < n-1; i++) {
            int u, v;
            cin >> u >> v;
            g[u-1].push_back(v-1);
            g[v-1].push_back(u-1);
        }
        
        unordered_map<int, int> cnt;
        for (int u = 0; u < n; u++) {
            int deg = g[u].size() - 1;
            if (u == 0) deg++;
            cnt[deg]++;
        }
        
        long long ans = 0;
        for (auto [k, v] : cnt) {
            ans += 1LL * v * (v-1) / 2;
        }
        cout << ans << endl;
    }
    return 0;
}

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        
        while (t-- > 0) {
            int n = scan.nextInt();
            List<List<Integer>> tree = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                tree.add(new ArrayList<>());
            }
            
            for (int i = 0; i < n-1; i++) {
                int u = scan.nextInt() - 1;
                int v = scan.nextInt() - 1;
                tree.get(u).add(v);
                tree.get(v).add(u);
            }
            
            Map<Integer, Integer> cnt = new HashMap<>();
            for (int u = 0; u < n; u++) {
                int deg = tree.get(u).size() - 1;
                if (u == 0) deg++;
                cnt.put(deg, cnt.getOrDefault(deg, 0) + 1);
            }
            
            long ans = 0;
            for (int v : cnt.values()) {
                ans += (long)v * (v-