✅ 春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：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: 点头问题

题目描述

两个人面对面坐着交谈，每当他们觉得对方说的不错时就会点头表示赞同。当两人同时点头时，会导致头部碰撞。小基需要在中间伸手阻止碰撞，问小基一共需要伸手几次。

输入格式

第一行输入一个整数 ()代表对话时长。 接下来两行分别输入长度为 的由 和 组成的字符串，表示两人在每个时刻是否点头。

输出格式

输出一个整数，表示小基需要伸手的次数。

样例

输入：

4
1001
0101

输出：

1

题解

只需要统计两个字符串相同位置同时为 1 的次数即可。时间复杂度 。

代码实现

C++:

#include <iostream>
using namespace std;

int main() {
    int len;
    string str1, str2;
    cin >> len >> str1 >> str2;
    
    int cnt = 0;
    for(int i = 0; i < len; i++) {
        if(str1[i] == '1' && str2[i] == '1') {
            cnt++;
        }
    }
    cout << cnt << 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();
        String seq1 = scan.next();
        String seq2 = scan.next();
        
        int total = 0;
        for(int idx = 0; idx < size; idx++) {
            if(seq1.charAt(idx) == '1' && seq2.charAt(idx) == '1') {
                total++;
            }
        }
        System.out.println(total);
    }
}

Python:

def count_collisions():
    n = int(input())
    seq_1 = input()
    seq_2 = input()
    
    total = sum(1 for i in range(n) if seq_1[i] == '1' and seq_2[i] == '1')
    return total

if __name__ == "__main__":
    print(count_collisions())

题目 2: 染色问题

题目描述

小柯正在对一个长度为 的数组进行染色。初始时所有元素均为无色。每次可以选择以下操作之一：

1. 选择一个位置染成红色
2. 选择一个区间 ，如果该区间内红色元素数量多于无色元素，则将整个区间染成红色

求将整个数组染成红色的最少操作次数。

输入格式

第一行输入整数 ()表示测试用例数。 每个测试用例一行，输入一个整数 ()。

输出格式

每个测试用例输出一行，表示最少操作次数。

样例

输入：

3
3
4
12

输出：

3
4
6

题解

对于长度小于等于 2 的数组，操作次数等于数组长度。对于更长的数组，前两次操作会染红两个位置，之后每次操作可以染红 个位置（ 为当前红色位置数）。时间复杂度 。

代码实现

C++:

#include <iostream>
using namespace std;

int main() {
    int test_num;
    cin >> test_num;
    
    while(test_num--) {
        long long arr_len;
        cin >> arr_len;
        
        if(arr_len <= 2) {
            cout << arr_len << endl;
            continue;
        }
        
        long long red = 2, ops = 2;
        while(red < arr_len) {
            red += red - 1;
            ops++;
        }
        cout << ops << endl;
    }
    return 0;
}

Java:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int testCnt = scan.nextInt();
        
        while(testCnt-- > 0) {
            long arrSize = scan.nextLong();
            
            if(arrSize <= 2) {
                System.out.println(arrSize);
                continue;
            }
            
            long redCnt = 2, opCnt = 2;
            while(redCnt < arrSize) {
                redCnt += redCnt - 1;
                opCnt++;
            }
            System.out.println(opCnt);
        }
    }
}

Python:

def solve_test():
    tests = int(input())
    for _ in range(tests):
        size = int(input())
        if size <= 2:
            print(size)
            continue
            
        red_num, op_num = 2, 2
        while red_num < size:
            red_num += red_num - 1
            op_num += 1
        print(op_num)

if __name__ == "__main__":
    solve_test()

题目 3: 标签分配

题目描述

小兰有 种不同的标签，每种标签只有一个。对于第 个物品，贴上 号标签后美观值为 ，不贴则为 。求所有物品的最大美观值之和。

输入格式

第一行输入两个整数 ()。 第二行输入 个整数 ()。 第三行输入 个整数 ()。 第四行输入 个整数 ()。

输出格式

输出一个整数，表示最大美观值之和。

样例

输入：

3 3
1 2 1
5 4 3
-1 2 -100

输出：

6

题解

使用贪心算法，按标签分类后，每类中选择美观度增量最大的物品贴标签。时间复杂度 。

代码实现

C++:

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

int calc_max_beauty(int sz, int tag_cnt, vector<int>& tag_type, 
                   vector<int>& with_tag, vector<int>& no_tag) {
    vector<vector<int>> groups(tag_cnt + 1);
    for(int i = 0; i < sz; i++) {
        groups[tag_type[i]].push_back(i);
    }
    
    int sum = 0;
    for(auto& grp : groups) {
        if(grp.empty()) continue;
        
        sort(grp.begin(), grp.end(), 
             [&](int x, int y) { return no_tag[x] - with_tag[x] < no_tag[y] - with_tag[y]; });
             
        sum += max(with_tag[grp[0]], no_tag[grp[0]]);
        for(int i = 1; i < grp.size(); i++) {
            sum += no_tag[grp[i]];
        }
    }
    return sum;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> a(n), b(n), c(n);
    
    for(int i = 0; i < n; i++) cin >> a[i];
    for(int i = 0; i < n; i++) cin >> b[i];
    for(int i = 0; i < n; i++) cin >> c[i];
    
    cout << calc_max_beauty(n, m, a, b, c) << endl;
    return 0;
}

题目 4: 地雷引爆

题目描述

小基来到了一个无限大的二维平面上，平面中有 个地雷。第 个地雷的坐标为 ，在 秒时会爆炸，爆炸冲击会引爆与其曼哈顿距离在 以内的所有地雷。求至少需要多长时间才能使至少 个地雷爆炸。

输入格式

第一行输入整数 ()表示测试用例数。 每个测试用例第一行输入两个整数 ()。 接下来 行，每行输入四个整数 ()。 所有 之和不超过 。

输出格式

每个测试用例输出一行，表示最少等待时间。

样例

输入：

1
3 3
0 0 0 1
1 0 1 1
2 2 3 10

输出：

3

题解

先按爆炸时间排序，用邻接表存储每个地雷能引爆的其他地雷，然后用 DFS 计算连锁反应。时间复杂度 。

代码实现

C++:

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

class MineSolver {
private:
    vector<bool> vis;
    vector<vector<int>> adj;
    
    int dfs(int u) {
        if(!vis[u]) return 0;
        vis[u] = false;
        int sum = 1;
        for(int v : adj[u]) sum += dfs(v);
        return sum;
    }

public:
    void solve() {
        int n, m;
        cin >> n >> m;
        vector<vector<long long>> mines(n, vector<long long>(4));
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < 4; j++) {
                cin >> mines[i][j];
            }
        }
        
        sort(mines.begin(), mines.end(), 
             [](const auto& a, const auto& b) { return a[2] < b[2]; });
        
        adj.assign(n, vector<int>());
        vis.assign(n, true);
        
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(abs(mines[i][0] - mines[j][0]) + 
                   abs(mines[i][1] - mines[j][1]) <= mines[i][3]) {
                    adj[i].push_back(j);
                }
            }
        }
        
        int total = 0;
        for(int i = 0; i < n; i++) {
            total += dfs(i);
            if(total >= m) {
                cout << mines[i][2] << '\n';
                break;
            }
        }
    }
};

int main() {
    int t;
    cin >> t;
    MineSolver solver;
    while(t--) solver.solve();
    return 0;
}

Java:

import java.util.*;

public class Main {
    static class MineGame {
        private boolean[] visited;
        private List<Integer>[] graph;
        private int[][] mineData;
        
        private int explode(int pos) {
            if(!visited[pos]) return 0;
            visited[pos] = false;
            int count = 1;
            for(int next : graph[pos]) {
                count += explode(next);
            }
            return count;
        }
        
        public void solve(Scanner in) {
            int size = in.nextInt();
            int target = in.nextInt();
            
            mineData = new int[size][4];
            for(int i = 0; i < size; i++) {
                for(int j = 0; j < 4; j++) {
                    mineData[i][j] = in.nextInt();
                }
            }
            
            Arrays.sort(mineData, (a, b) -> Integer.compare(a[2], b[2]));
            
            graph = new List[size];
            visited = new boolean[size];
            for(int i = 0; i < size; i++) {
                graph[i] = new ArrayList<>();
                visited[i] = true;
            }
            
            for(int i = 0; i < size; i++) {
                for(int j = 0; j < size; j++) {
                    if(Math.abs(mineData[i][0] - mineData[j][0]) + 
                       Math.abs(mineData[i][1] - mineData[j][1]) <= mineData[i][3]) {
                        graph[i].add(j);
                    }
                }
            }
            
            int total = 0;
            for(int i = 0; i < size; i++) {
                total += explode(i);
                if(total >= target) {
                    System.out.println(mineData[i][2]);
                    break;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tests = in.nextInt();
        MineGame game = new MineGame();
        while(tests-- > 0) game.solve(in);
    }
}

Python:

class MineField:
    def __init__(self):
        self.vis = []
        self.adj = []
        
    def dfs(self, u):
        if not self.vis[u]:
            return 0
        self.vis[u] = False
        return 1 + sum(self.dfs