2024-09-08 小红书机试解题报告

前言

在这里插入图片描述

题解

这是2024年9月8号的小红书机试题。

看到群里有人在讨论，小红书的机试题，顺手做了下，感觉挺有意思的。

现在的机试题，是真的难，好卷。

A. 机器人

题目描述:
m * n的格子，都有一个方向指令LRUD。而每个格子上的机器人必须按格子的方向指令行走，求最后还留在格子里的机器人数。
初始时，每个格子上都有一个机器人，且行动彼此不受影响。

输入

2 5
LRRLR
UULLR

输出

思路: 正向遍历/逆向拓扑排序

这类激光反射格子的题，有一些经典的结论：

每条路径彼此独立，没有交集
每条路径要么有一个环，要么从矩阵边界出去

所以图中，可以剥离出，基环树和单链两种类型。

而最终能剩下的机器人，就是在基环树的格子上。

从逆向的角度求解，就是拓扑排序

我们把每个格子抽象为一个节点，
$图中每个节点只有一条出边 (出界不算) ，即出度为 1$

逆向建图，即出边构建反向边，然后跑一遍拓扑排序，这样就可以把哪些单向链求解出来。

这样的时间复杂度为 $O (n * m)$

#include <bits/stdc++.h>

using namespace std;

int main() {
    
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    
    int h, w;
    cin >> h >> w;
    vector<string> grid(h);
    for (int i = 0;i < h; i++) {
        cin >> grid[i];
    }
    
    // 反向构建拓扑图
    vector<vector<int>> deg(h, vector<int>(w, 0));
    vector<vector<vector<int>>> g(h, vector<vector<int>>(w));
    
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            char c = grid[i][j];
            if (c == 'L') {
                if (j > 0) {
                    g[i][j - 1].push_back(i * w + j);
                    deg[i][j - 1]++;
                }
            } else if (c == 'R') {
                if (j + 1 < w) {
                    g[i][j + 1].push_back(i * w + j);
                    deg[i][j + 1]++;
                }
            } else if (c == 'U') {
                if (i > 0) {
                    g[i - 1][j].push_back(i * w + j);
                    deg[i - 1][j]++;
                }
            } else if (c == 'D') {
                if (i + 1 < h) {
                    g[i + 1][j].push_back(i * w + j);
                    deg[i + 1][j]++;
                }
            }
        } 
    }
    
    // 拓扑排序板子
    deque<array<int, 2>> que;
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            if (deg[i][j] == 0) {
                que.push_back({i, j});
            }
        }
    }
    int ans = 0;
    while (!que.empty()) {
        auto cur = que.front();
        que.pop_front();
        ans++;
        int y = cur[0], x = cur[1];
        for (int v: g[y][x]) {
            int ty = v / w, tx = v % w;
            if (--deg[ty][tx] == 0) {
                que.push_back({ty, tx});
            }
        }
    }
    
    cout << (h * w - ans) << endl;
    return 0;
    
}

从正向的角度，就是遍历，由于只有一个出口，所以单纯的for循环即可。

这里需要染色去重，时间复杂度也为 $O (n * m)$ .

感觉正向去编写，更快更便捷。

B. 小苯的区间之和

题目描述:

可以重排数组，使得

$\sum_{i=0}^{i=n}\sum_{j=i}^{j=n} f(i, j) 最小，f(i, j) 为子数组[i, j]的区间和$

思路: 贡献法

就是统计每个元素，在所有的子数组的次数

$w_i = (i + 1) * (n - i)$

重新排列值，求最小的所有子数组和？

那贪心得到，高权重配低数值，这样必然结果最小。

#include <bits/stdc++.h>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> arr(n);
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
    }
    
    // 计算贡献
    vector<int64_t> w(n);
    for (int i = 0; i < n; ++i) {
        w[i] = (int64_t)(i + 1) * (n - i);
    }

    sort(w.begin(), w.end());
    sort(arr.rbegin(), arr.rend());

    // 逆向配对
    int64_t ans = 0;
    for (int i = 0; i < n; ++i) {
        ans += (int64_t)w[i] * arr[i];
    }

    cout << ans << endl;
    return 0;
}

C. 小红的笔记精选

题目描述:

简单来说，就是寻找最长的序列，其满足

该序列中每个元素的二进制1的个数都相等
该序列满足自然递增

思路: 分组+Map/构造

就是按照二进制的1个数，分组

然后每个分组，构建寻找最长的连续序列

其实难点在于，如何构造某数的下一个值。

我是刷表法构造的

对于值x

添加 lowbit = x & -x
从末尾出发，补足下一个数的二进制的1个数

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cstdio>

using namespace std;

int main() {
    int n;
    scanf("%d", &n);
    unordered_map<int, vector<long long>> hp;

    for (int i = 0; i < n; i++) {
        long long v;
        scanf("%lld", &v);
        int cnt = __builtin_popcountll(v);
        hp[cnt].push_back(v);
    }

    int res = 0;

    for (auto& ent : hp) {
        vector<long long>& lst = ent.second;
        sort(lst.begin(), lst.end());

        int nk = ent.first;
        unordered_map<long long, int> dp;
        for (auto& v : lst) {
            dp[v] = 1;
        }

        for (auto& v : lst) {
            int z = dp[v];
            res = max(res, z);

            long long low = v & (-v);
            long long nv = v + low;
            int n1 = __builtin_popcountll(nv);
            
            for (int i = 0; n1 < nk && i < 30; i++) {
                if (n1 < nk) {
                    if (((1LL << i) & nv) == 0) {
                        nv |= (1LL << i);
                        n1++;
                    }
                }
            }

            if (dp.find(nv) != dp.end()) {
                dp[nv] = max(dp[nv], z + 1);
            }
        }
    }

    printf("%d\n", res);

    return 0;
}