下面是美团2024-03-09笔试真题，笔者进行了VP，由于未参与评测，故不保证正确性，仅供参考。

第一题 小美的MT

首先找到原来字符串中含有的M和T的数量，记作cnt。然后剩余n - cnt个字符是可以修改的，但这取决于k，故可以修改的个数为min(k, n - cnt)。因此答案就是cnt + min(k, n - cnt)。

#include <bits/stdc++.h>
using namespace std;
int n, k, cnt;
string s;

int main() {
    scanf("%d%d", &n, &k);
    cin >> s;
    for (auto& c: s)
        if (c == 'M' || c == 'T')
            ++ cnt;
    printf("%d\n", cnt + min(k, n - cnt));
}

第二题 小美的数组询问

首先统计数组a中所有元素的总和，记作s。然后统计数组a中元素0的个数，记作zeros。显然，最小值就是：zeros * l。最大值就是：zeros * r。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
using LL = long long ;
int a[N], n, Q, l, r;

int main() {
    scanf("%d%d", &n, &Q);
    LL s = 0, zeros = 0;
    for (int i = 0; i < n; ++ i) {
        scanf("%d", &a[i]);
        s += a[i];
        if (a[i] == 0)  ++ zeros;
    }

    while (Q -- ) {
        scanf("%d%d", &l, &r);
        printf("%lld %lld\n", s + zeros * l, s + zeros * r);
    }
}

第三题 小美的平衡矩阵

考察二维前缀和。

可以先预处理出二维前缀和数组。然后由于n只有200，所以直接枚举所有的边长i的正方形，判断正方形的和是否为i * i / 2即可。

#include <bits/stdc++.h>
using namespace std;
const int N = 210;
char g[N][N];
int s[N][N], ans[N], n;

inline int solve(int x1, int y1, int x2, int y2) {
    return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 -1] + s[x1 - 1][y1 - 1];
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            cin >> g[i][j];
            s[i][j] = g[i][j] - '0';
        }
    }

    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= n; ++ j)
            s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];

    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            for (int k = 1; k <= n; ++ k) {
                if (i + k - 1 <= n && j + k - 1 <= n) {
                    int x = solve(i, j, i + k - 1, j + k - 1);
                    if (x * 2 == k * k) ++ ans[k];
                }
            }
        }
    }

    for (int i = 1; i <= n; ++ i)   printf("%d\n", ans[i]);
}

第四题 小美的区间删除

首先，我们需要知道：乘积末尾有$k$个$0$意味着乘积可以被$10^k$整除，又$10=2\times 5$。因此，问题转化为找到删除区间后，剩余所有元素的乘积中$2$和$5$的因子数量都至少有$k$个。

1. 预处理出每个元素含有的因子$2$和因子$5$的个数，分别记录到cnt2和cnt5数组中。然后用变量c2和c5记录所有因子$2$和所有因子$5$的总数。
2. 然后我们可以使用双指针来维护一个滑动窗口。使用双指针$l$（左指针）和$r$（右指针）遍历数组。对于每个右指针的位置$r$，尝试移动左指针$l$，直到当前考虑的区间（从$l$到$r$）外的部分（即删除这个区间后的数组部分）的乘积末尾的$0$的数量不小于$k$。这是通过确保c2和c5（即当前考虑的区间外部分的因子$2$和$5$的总数）的最小值不小于$k$来实现的。对于每个右指针$r$的位置，计算满足条件的左指针$l$的数量，并累加到ans。这里，ans += r - l + 1;是因为对于每个固定的右指针$r$，从$l$到$r$的所有位置都可以作为左指针，形成一个有效的区间。
3. 最后，输出满足条件的连续子数组的总数ans。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
using LL = long long;
int a[N], cnt2[N], cnt5[N], n, k;

int get(int x, int p) {
    int ans = 0;
    while (x % p == 0) {
        x /= p;
        ++ ans;
    }
    return ans;
}

int main() {
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; ++ i)    scanf("%d", &a[i]);

    int c2 = 0, c5 = 0;
    for (int i = 0; i < n; ++i) {
        cnt2[i] = get(a[i], 2);
        cnt5[i] = get(a[i], 5);
        c2 += cnt2[i], c5 += cnt5[i];
    }

    LL ans = 0;
    for (int l = 0, r = 0; r < n; ++ r) {
        c2 -= cnt2[r], c5 -= cnt5[r];
        while (min(c2, c5) < k) {
            c2 += cnt2[l], c5 += cnt5[l];
            ++ l;
        }
        ans += r - l + 1;
    }

    printf("%lld\n", ans);
}

第五题 小美的朋友关系

这题其实与 P1197 星球大战 类似。一眼并查集，而且还是涉及到并查集删除问题。

但是我们知道并查集并不支持删除操作。一般涉及到并查集删除问题的解题套路：正难则反，逆向思考。

（1）首先构建出原图：

    for (int i = 0; i < m; ++ i) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }

（2）然后在原图中标记出要删除的边（图中红色边表示要删除），不妨称这个图为标记图：

    ops.resize(Q);
    for (int i = 0; i < Q; ++ i) {
        int op, a, b;
        scanf("%d%d%d", &op, &a, &b);
        // 标记要删除的边（此时点a和点b之间的这条边就是要删除的）
        if (op == 1)    st[a] = st[b] = true;
        ops[i] = {op, a, b};
    }

（3）然后根据标记图，不考虑删除边，然后进行并查集合并，不妨称为初始并查集：

    for (int i = 0; i < idx; ++ i) {
        int a = e[i ^ 1], b = e[i];
        // 说明点a和点b之间的这条边是删除边
        if (st[a] && st[b]) continue;
        merge(a, b);
    }

（4）然后逆向遍历所有的q次操作，如果是查询，使用并查集直接查出即可；如果是删除，则往并查集添加边。为什么需要逆向遍历呢？这是因为在原图中，比如先删除边$(a,b)$再删除边$(u,v)$是会对图产生影响的，因为删除边$(u,v)$是在删除边$(a,b)$后的图上在进行的删除操作。但是我们此时是要往图中加边，因此需要先从后面的状态开始加边。也就是说逆向加边才能保证和正向删边的状态一致性。

    for (int i = Q - 1; i >= 0; -- i) {
        int op = ops[i][0], a = ops[i][1], b = ops[i][2];
        if (op == 1) {
            merge(a, b);
        } else {
            if (find(a) == find(b)) ans.push_back("Yes");
            else    ans.push_back("No");
        }
    }

完整实现：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 2e5 + 10; 
int h[N], e[M], ne[M], idx;
int p[N], n, m, Q;
bool st[N];
vector<vector<int>> ops;
vector<string> ans;

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

int find(int x) {
    if (x != p[x])  p[x] = find(p[x]);
    return p[x];
}

void merge(int a, int b) {
    a = find(a), b = find(b);
    if (a != b) p[a] = b;
}

int main() {
    memset(h, -1, sizeof h);
    scanf("%d%d%d", &n, &m, &Q);

    for (int i = 1; i <= n; ++ i)   p[i] = i;

    for (int i = 0; i < m; ++ i) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }

    ops.resize(Q);
    for (int i = 0; i < Q; ++ i) {
        int op, a, b;
        scanf("%d%d%d", &op, &a, &b);
        if (op == 1)    st[a] = st[b] = true;
        ops[i] = {op, a, b};
    }

    for (int i = 0; i < idx; ++ i) {
        int a = e[i ^ 1], b = e[i];
        if (st[a] && st[b]) continue;
        merge(a, b);
    }

    for (int i = Q - 1; i >= 0; -- i) {
        int op = ops[i][0], a = ops[i][1], b = ops[i][2];
        if (op == 1) {
            merge(a, b);
        } else {
            if (find(a) == find(b)) ans.push_back("Yes");
            else    ans.push_back("No");
        }
    }

    reverse(ans.begin(), ans.end()); 
    for (auto &x : ans) cout << x << endl;

    return 0;
}

---