✅ 春招备战指南 ✅

💡 学习建议：

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

互联网必备刷题宝典🔗

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

⏰ 笔试时间安排

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

🧩 笔试题型分布

⚙️ 考试设置要点

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

📚 笔试经验贴

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

本题库收录整理自：

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

🔍 题库特点：

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

⚠️ 注意事项：

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

🚀 春招备战指南

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

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

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

真题详解（改编版）

第一题：密码尝试

题目内容

小基准备登录美团，需要输入密码。小基忘记了密码，只记得密码可能是 个字符串中的一个。小基会按照密码的长度从小到大依次尝试每个字符串，对于相同长度的字符串，小基随机尝试，并且相同的密码只会尝试一次。小基想知道，她最少需要尝试多少次才能登录成功，最多需要尝试多少次才能登录成功。

输入描述

第一行输入一个整数 （）代表密码字符串的个数。 第二行输入一个只由小写字母组成的字符串 （）代表正确的密码。 接下来 行，每行输入一个长度不超过 1000 的字符串，代表小基记得的密码。

输出描述

在一行上输出两个整数，表示最少和最多尝试次数。

样例1

输入：

4
ab
abc
ab
ac
ab

输出：

1 2

说明：小基可能按照["ab","ac","abc"]的顺序尝试，第一次尝试成功，也可能按照["ac","ab","abc"]的顺序尝试，第二次尝试成功。

题解

这道题的关键是要先对字符串按长度排序，然后对于相同长度的字符串，需要考虑最好情况（正确密码最先尝试）和最坏情况（正确密码最后尝试）。

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

三语言参考代码

• C++

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    string ans;
    cin >> ans;
    vector<string> passwords;
    set<string> seen;
    
    // 去重并按长度排序
    for(int i = 0; i < n; i++) {
        string s;
        cin >> s;
        if(!seen.count(s)) {
            seen.insert(s);
            passwords.push_back(s);
        }
    }
    sort(passwords.begin(), passwords.end(), 
         [](const string& a, const string& b) {
             return a.length() < b.length();
         });
    
    // 找到最小和最大尝试次数
    int minTries = 1, maxTries = 1;
    int sameLen = 0;
    for(int i = 0; i < passwords.size(); i++) {
        if(passwords[i] == ans) {
            if(i > 0 && passwords[i].length() == passwords[i-1].length()) {
                maxTries = sameLen + 1;
            }
            break;
        }
        if(i > 0 && passwords[i].length() == passwords[i-1].length()) {
            sameLen++;
        } else {
            sameLen = 1;
        }
        minTries++;
    }
    
    cout << minTries << " " << maxTries << endl;
    return 0;
}

• Python

n = int(input())
correct = input()
passwords = []
seen = set()

# 去重并按长度排序
for _ in range(n):
    pwd = input()
    if pwd not in seen:
        seen.add(pwd)
        passwords.append(pwd)
passwords.sort(key=len)

# 找到最小和最大尝试次数
min_tries = max_tries = 1
same_len = 0
for i, pwd in enumerate(passwords):
    if pwd == correct:
        if i > 0 and len(pwd) == len(passwords[i-1]):
            max_tries = same_len + 1
        break
    if i > 0 and len(pwd) == len(passwords[i-1]):
        same_len += 1
    else:
        same_len = 1
    min_tries += 1

print(min_tries, max_tries)

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String correct = sc.next();
        
        // 去重并按长度排序
        Set<String> seen = new HashSet<>();
        List<String> passwords = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            String pwd = sc.next();
            if(!seen.contains(pwd)) {
                seen.add(pwd);
                passwords.add(pwd);
            }
        }
        Collections.sort(passwords, (a, b) -> a.length() - b.length());
        
        // 找到最小和最大尝试次数
        int minTries = 1, maxTries = 1;
        int sameLen = 0;
        for(int i = 0; i < passwords.size(); i++) {
            if(passwords.get(i).equals(correct)) {
                if(i > 0 && passwords.get(i).length() == 
                   passwords.get(i-1).length()) {
                    maxTries = sameLen + 1;
                }
                break;
            }
            if(i > 0 && passwords.get(i).length() == 
               passwords.get(i-1).length()) {
                sameLen++;
            } else {
                sameLen = 1;
            }
            minTries++;
        }
        
        System.out.println(minTries + " " + maxTries);
    }
}

第二题：数组清空

题目内容

小基有一个长度为 的数组 ，她可以对数组进行如下操作：

1. 删除第一个元素 ，同时数组的长度减 1，花费为 。
2. 删除整个数组，花费为 （其中 表示数组中未出现过的最小非负整数）。

小基想知道将数组全部清空的最小代价是多少。

输入描述

第一行输入一个整数 （）代表测试数据组数。 每组数据第一行输入三个正整数 （）。 第二行输入 个整数 （）。

输出描述

对于每组测试数据，输出一个整数表示最小花费。

样例1

输入：

1
6 3 3
4 5 2 3 1 0

输出：

15

题解

这道题需要考虑两种操作的组合。可以先删除一些前缀元素，再一次性删除剩余数组。关键是要计算每种组合的花费，并找到最小值。

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

三语言参考代码

• C++

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int getMex(vector<int>& arr) {
    set<int> s(arr.begin(), arr.end());
    int mex = 0;
    while(s.count(mex)) mex++;
    return mex;
}

void solve() {
    int n, k, x;
    cin >> n >> k >> x;
    vector<int> a(n);
    for(int i = 0; i < n; i++) cin >> a[i];
    
    ll ans = LLONG_MAX;
    vector<int> curr = a;
    
    // 尝试删除不同数量的前缀元素
    for(int i = 0; i <= n; i++) {
        ll cost = (ll)i * x;  // 删除前缀的花费
        if(i < n) {
            vector<int> remain(a.begin() + i, a.end());
            cost += (ll)k * getMex(remain);  // 删除剩余数组的花费
        }
        ans = min(ans, cost);
    }
    
    cout << ans << endl;
}

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

• Python

def get_mex(arr):
    s = set(arr)
    mex = 0
    while mex in s:
        mex += 1
    return mex

def solve():
    n, k, x = map(int, input().split())
    a = list(map(int, input().split()))
    
    ans = float('inf')
    # 尝试删除不同数量的前缀元素
    for i in range(n + 1):
        cost = i * x  # 删除前缀的花费
        if i < n:
            remain = a[i:]
            cost += k * get_mex(remain)  # 删除剩余数组的花费
        ans = min(ans, cost)
    
    print(ans)

t = int(input())
for _ in range(t):
    solve()

• Java

import java.util.*;

public class Main {
    static long getMex(int[] arr, int start, int end) {
        Set<Integer> set = new HashSet<>();
        for(int i = start; i < end; i++) {
            set.add(arr[i]);
        }
        int mex = 0;
        while(set.contains(mex)) m