牛客小白月赛91文字版题解

小白月赛91文字版题解

在此感谢牛客官方工作人员,验题人简单，讲题人和参与内测的所有朋友。

本场题中E、F的通过人数比较出乎意料(内测中反馈都说比较典，本来预测通过人数会比较多，悲)，其他题目符合预期。

视频讲解：Bilibili-牛客竞赛

A.Bingbong的化学世界

知识点：基础语法

由于输入数据已经固定，所以我们只需要找出不是'.'的位置就可以判断出是属于哪种“苯环”。

时间复杂度：

题解代码：

#include<bits/stdc++.h>
using namespace std;
char a[10][10];
int main() {
    for (int i = 1; i <= 6; i++) {
        for (int j = 1; j <= 7; j++) {
            cin >> a[i][j];
        }
    }
    if (a[3][6] != '.') cout << "o";
    else if (a[6][4] != '.') cout << "p";
    else cout << "m";
    return 0;
}

B.Bingbong的数数世界

知识点：博弈思维

可以发现，在操作最优情况下如果存在对方的数都应该选择消除。

而后手必胜的条件即最终态时刚好剩余两个偶数+两个奇数，这样才能在先手、后手依次操作完以后先手无法操作。由于所有卡牌已经是的排列，故只需要判断对取模的余数即可。

时间复杂度：

题解代码：

#include<bits/stdc++.h>
using namespace std;
int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        if (n % 4 == 0) {
            cout << "Bong" << '\n';
        } else {
            cout << "Bing" << '\n';
        }
    }
    return 0;
}

C.Bingbong的蛋仔世界

知识点：思维

由于每个位置允许多只蛋仔存在，所以每个蛋仔本质上是独立的，只需要考虑每个蛋仔能不能到达终点即可。

对于每一只蛋仔，我们只需要计算它到达终点的所需总时间能否小于所在行和列中砖块消失最长时间即可。

时间复杂度：

代码：

#include<bits/stdc++.h>
using namespace std;
int main() {
    int n, m, k;
    cin >> n >> m >> k;
    int fx = n / 2 + 1, fy = m / 2 + 1;
    int ans = 0;
    for (int i = 1; i <= k; i++) {
        int x, y;
        cin >> x >> y;
        int time = abs(x - fx) + abs(y - fy);
        if (time < max(fx, fy)) ans++;
    }
    cout << ans;
    return 0;
}

D.Bingbong的奇偶世界

知识点：dp思维

我们可以分别考虑当一个数的结尾分别是的情况。

用记录所有满足条件的答案数量，用来记录前面可以形成的所有数的个数。

时：

我们发现此数可以接在前面的任意数的后面，且以为后导的数是满足条件的，并且这个不能作为前导,故可得：

时：

我们发现此数可以接在前面的任意数的后面，但不是满足条件的答案，故可得：

时：

我们发现此数可以接在前面的任意数的后面，是满足条件的答案,故可得：

最后再对各个部分取模即可。

时间复杂度：

代码：

#include<bits/stdc++.h>
using namespace std;
#define i64 long long
const i64 mod = 1e9 + 7;
int main() {
    int n;
    cin >> n;
    vector<char>s(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
    }
    i64 ans = 0, cnt = 0;;
    for (int i = 1; i <= n; i++) {
        if (s[i] == '0') {
            ans = (ans + cnt + 1) % mod;
            cnt = (cnt * 2) % mod;
        } else if ((s[i] - '0') & 1) {
            cnt = (cnt * 2 + 1) % mod;
        } else {
            ans = (ans + cnt + 1) % mod;
            cnt = (cnt * 2 + 1) % mod;
        }
    }
    cout << ans;
    return 0;
}

E.Bingbong的字符串世界

知识点：序列自动机

入手点是考虑对于任意为起点满足条件的字符串有多少个。

1.首先维护出对于任意的位置后面出现的字符为的位置，即。

2.然后对于第个位置，找出右边索引中满足存在子序列中的最小位置，然后再找出的最小位置。如果此时存在且那么此时的满足条件的字符串必然不可能存在。否则继续判断。

3.此时，我们需要讨论存在和不存在的情况。

当不存在时，需要加上满足长度大于等于且右索引不大于的字符串。

当存在时，需要加上满足长度大于等于且右索引不会大于等于的字符串。

由于此题细节较多，在代码中写出部分注释。

时间复杂度：

代码：

#include<bits/stdc++.h>
using namespace std;
#define i64 long long
int Next_ACCEPT[6] = {1, 3, 3, 5, 16, 20,};
int Next_WA[2] = {23, 1};
int main() {
    i64 ans = 0;
    int n, k;
    cin >> n >> k;
    vector<char>s(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
    }
    //序列自动机--维护第i个位置右边出现字符j的第一个位置
    vector<vector<int>>f(n + 2, vector<int>(27, -1));
    for (int i = n; i >= 1; i--) {
        for (int j = 1; j <= 26; j++) {
            f[i][j] = f[i + 1][j];
        }
        f[i][s[i] - 64] = i;
    }
    //计算以当前i为左端点开始满足条件的子串的数目
    for (int i = 1; i <= n; i++) {
        int t1 = i;
        for (int j = 0; j < 6; j++) {
            if (j == 2 && s[t1] == 'C') t1 = f[t1 + 1][Next_ACCEPT[j]]; //防止一个C被判断两次
            else  t1 = f[t1][Next_ACCEPT[j]];
            if (t1 == -1) break;
        }
        if (t1 == -1) continue;
        int t2 = i;
        for (int j = 0; j < 2; j++) {
            t2 = f[t2][Next_WA[j]];
            if (t2 == -1) break;
        }
        if (t2 != -1 && t2 <= t1) continue;
        if (t2 == -1) {
            if (i + k - 1 > n) continue;
            else {
                ans = ans + n - max(i + k - 1, t1) + 1;
            }
        } else {
            if (i + k - 1 >= t2) continue;
            else {
                ans = ans + t2 - max(t1, i + k - 1);
            }

        }
    }
    cout << ans ;
    return 0;
}

F.Bingbong的幻想世界

知识点：位运算

首先暴力做法的做法必然超时，所以考虑更优解。

对于每一个数,我们可以考虑它对二进制位上的贡献。

考虑二进制枚举到第位,数组枚举到第个。

当二进制的第位是的时候，我们可以得出在区间中在二进制的第位上是的数所贡献的区间个数为个,且影响的区间个数为之后的个，所以贡献即为，又因为一个区间需要两两异或运算，所以对于一对和需要计算两遍,故总贡献为。

同理计算即可。

时间复杂度：

代码：

#include<bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
#define i64 long long
int main() {
    int n;
    cin >> n;
    vector<i64>a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    i64 ans = 0;
    for (int t = 0; t <= 20; t++) {
        i64 v0 = 0;
        i64 v1 = 0;
        for (int i = 1; i <= n; i++) {
            if ((a[i] >> t) & 1) {
                ans = (ans + v0 * (n - i + 1) % mod * (1 << t) % mod * 2 % mod) % mod;
                v1 = (v1 + i) % mod;
            } else {
                ans = (ans + v1 * (n - i + 1) % mod * (1 << t) % mod * 2 % mod) % mod;
                v0 = (v0 + i) % mod;
            }
        }
    }
    cout << ans ;
    return 0;
}

G.Bingbong的回文路径

知识点：

做法一：最近公共祖先，字符串哈希

做法二：后缀数组+树链分治

做法一：

.最近公共祖先，字符串哈希

:首先介绍一种比较不严谨的写法(因为字符串哈希本身带有哈希冲突)，但是比较好理解这题，考虑是小白月赛以学习为目的，所以没有卡这种做法(好像也不好卡)。

思路：首先我们需要预处理​的函数，以及到达第个结点时从上到下的幂次逐渐变高的数组和从上到下的幂次逐渐变低的数组的两种字符串哈希值。然后通过两点找到。令为 to ,为 to

当做为左串时，字符串为： to ,此时 使用数组的哈希值，使用数组的哈希值，然后减掉到根节点这部分多余的哈希值，再用逆元处理掉多余的的幂次，两个哈希值处理到对应的幂次后相加得到.

当做为左串时，可同上进行计算得到。

当此串为回文串时应该满足=。

(内测的佬说也可以不用逆元，倍增同时处理也可，可自行选择参考)

时间复杂度：

参考代码：(非唯一)

#include<bits/stdc++.h>
using namespace std;
#define i64 long long
const int mod = 1e9 + 7;
const int P = 13331;
void solve() {
    int n;
    cin >> n;
    vector<char>a(n + 1); 
    vector<int>e[n + 1]; 
    vector<vector<int>>f(n + 1, vector<int>(32, 0)); 
    vector<i64>p(n + 1); 
    vector<i64>s(n + 1); 
    vector<i64>g(n + 1); 
    vector<int>d(n + 1, 1e9); 
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) {
        int fa;
        cin >> fa;
        e[fa].push_back(i);
        e[i].push_back(fa);
    }

    p[0] = 1;
    for (int i = 1; i <= n; i++) {
        p[i] = p[i - 1] * P % mod;
    }

    auto bfs = [&](int root) {
        queue<int>q;
        q.push(root);
        d[root] = 0;
        s[root] = a[root];
        g[root] = a[root];
        while (!q.empty()) {
            auto t = q.front();
            q.pop();
            for (int i = 0; i < e[t].size(); i++) {
                int j = e[t][i];
                if (d[j] <= d[t] + 1) continue;
                d[j] = d[t] + 1;
                q.push(j);
                f[j][0] = t;
                for (int k = 1; k <= 31; k++) {
                    f[j][k] = f[f[j][k - 1]][k - 1];
                }
                s[j] = (s[t] + p[d[j]] * (a[j] - 0) % mod) % mod;
                g[j] = (g[t] * P % mod + a[j] - 0) % mod;

            }
        }
    };
    bfs(1);
    d[0] = -1;
    auto LCA = [&](int u, int v) ->int {
        if (d[u] < d[v])swap(u, v);
        for (int i = 31; i >= 0; i--) {
            if (d[f[u][i]] >= d[v]) {
                u = f[u][i];
            }
        }
        if (u == v) return u;
        for (int i = 31; i >= 0; i--) {
            if (f[u][i] != f[v][i]) {
                u = f[u][i];
                v = f[v][i];
            }
        }
        u = f[u][0];
        v = f[u][0];
        return u;
    };
    auto ksm = [&](i64 a, i64 b) ->i64{
        i64 ans = 1;
        while (b) {
            if (b & 1) ans = ans * a % mod;
            a = a * a % mod;
            b >>= 1;
        }
        return ans;
    };
    int q;
    cin >> q;
    while (q--) {
        int u, v;
        cin >> u >> v;
        int fa = LCA(u, v);
        i64 p1 = (s[u] - s[fa] + mod) % mod;
        p1 = p1 * ksm(p[d[fa]], mod - 2) % mod;
        p1 = (p1 + a[fa]) % mod;
        p1 = (p1 * p[d[v] % mod - d[fa]] + mod) % mod;
        i64 p2 = (g[v] - g[fa] * p[d[v] - d[fa]] % mod + mod) % mod;
        i64 ans1 = (p1 + p2) % mod;
        p1 = 0, p2 = 0;
        p1 = (s[v] - s[fa] + mod) % mod;
        p1 = p1 * ksm(p[d[fa]], mod - 2) % mod;
        p1 = (p1 + a[fa]) % mod;
        p1 = (p1 * p[d[u] % mod - d[fa]] + mod) % mod;
        p2 = (g[u] - g[fa] * p[d[u] - d[fa]] % mod + mod) % mod;
        i64 ans2 = (p1 + p2) % mod;
        if (ans1 == ans2) cout << "YES" << '\n';
        else cout << "NO" << '\n';
    }
}
int main() {
    int T = 1;
    while (T--) {
        solve();
    }
    return 0;
}

做法二：

接下来介绍一种比较严谨的写法。

首先对此有根树轻重链分治，对每条链把它从上到下按顺序访问的节点的值和从下到上访问的值缝起来串到一个串里面，然后对缝起来后的串求后缀数组，此时便可以快速求两个后缀的，之后便可以快速对比两个链的某个区间，通过判断可得该路径是否满足回文串。

时间复杂度：

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct graph {
    int head[N], nxt[N], to[N], cnt;
    inline graph(): cnt(1) {}
    inline void add(int u, int v) {
        nxt[++cnt] = head[u];
        to[cnt] = v;
        head[u] = cnt;
    }
} gr;
char s[N];
int n, q, sz[N], son[N], top[N], father[N], dep[N], zidx[N], fidx[N], tmp[N];
bool vis[N];
char t[N << 1];
int len;
inline bool cmp(int x, int y) {
    return dep[x] > dep[y];
}
void dfs1(int u) {
    sz[u] = 1;
    dep[u] = dep[father[u]] + 1;
    for (int i = gr.head[u]; i; i = gr.nxt[i]) {
        int v = gr.to[i];
        dfs1(v);
        sz[u] += sz[v];
        if (sz[v] > sz[son[u]]) {
            son[u] = v;
        }
    }
}
void dfs2(int u) {
    if (son[u]) {
        top[son[u]] = top[u];
        dfs2(son[u]);
        for (int i = gr.head[u]; i; i = gr.nxt[i]) {
            int v = gr.to[i];
            if (v == son[u])continue;
            top[v] = v;
            dfs2(v);
        }
    }
}
int sa[N << 1], rak[N << 2], oldrak[N << 2], idx[N << 1], h[N << 1],
    cnt[N << 1];
void getsa() {
    int m = max(255, n);
    for (int i = 1; i <= len; i++) {
        cnt[t[i]]++;
        rak[i] = t[i];
    }
    for (int i = 1; i <= m; i++) {
        cnt[i] += cnt[i - 1];
    }
    for (int i = len; i >= 1; i--) {
        sa[cnt[rak[i]]--] = i;
    }
    for (int L = 1, p; L <= len; L <<= 1, m = p) {
        p = 0;
        for (int i = len; i + L > len; i--) {
            idx[++p] = i;
        }
        for (int i = 1; i <= len; i++) {
            if (sa[i] > L) {
                idx[++p] = sa[i] - L;
            }
        }
        memset(cnt, 0, (m + 1)*sizeof(int));
        for (int i = 1; i <= len; i++) {
            cnt[rak[i]]++;
        }
        for (int i = 1; i <= m; i++) {
            cnt[i] += cnt[i - 1];
        }
        for (int i = len; i >= 1; i--) {
            sa[cnt[rak[idx[i]]]--] = idx[i];
        }
        memcpy(oldrak, rak, sizeof rak);
        p = 0;
        for (int i = 1; i <= len; i++) {
            if (oldrak[sa[i]] == oldrak[sa[i - 1]] &&
                    oldrak[sa[i] + L] == oldrak[sa[i - 1] + L]) {
                rak[sa[i]] = p;
            } else {
                rak[sa[i]] = ++p;
            }
        }
        if (p == len) {
            for (int i = 1; i <= len; i++) {
                sa[rak[i]] = i;
            }
            break;
        }
    }
    for (int i = 1, j = 0; i <= len; i++) {
        if (rak[i] == 1)continue;
        if (j)j--;
        while (t[i + j] == t[sa[rak[i] - 1] + j])j++;
        h[rak[i]] = j;
    }
}
struct node {
    int l, r;
    inline node(int l, int r): l(l), r(r) {}
};
vector<node> query(int x, int y) {
    vector<node> t0, t1;
    int xtag = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) {
            xtag ^= 1;
            swap(x, y);
        }
        if (xtag == 0) {
            t0.push_back(node(fidx[x], fidx[top[x]]));
        } else {
            t1.push_back(node(zidx[top[x]], zidx[x]));
        }
        x = father[top[x]];
    }
    if (dep[x] < dep[y]) {
        xtag ^= 1;
        swap(x, y);
    }
    if (xtag == 0) {
        t0.push_back(node(fidx[x], fidx[y]));
    } else {
        t1.push_back(node(zidx[y], zidx[x]));
    }
    vector<node> ret = t0;
    for (int i = t1.size() - 1; i >= 0; i--) {
        ret.push_back(t1[i]);
    }
    return ret;
}
int min_h[19][N << 1], logv[N];
int query_min(int l, int r) {
    int v = logv[r - l + 1];
    return min(min_h[v][l], min_h[v][r - (1 << v) + 1]);
}
int calc(int i, int j) {
    if (i == j)return len - i + 1;
    i = rak[i];
    j = rak[j];
    if (i > j)swap(i, j);
    return query_min(i + 1, j);
}
bool check(const vector<node>& t1, const vector<node>& t2) {
    int i = 0;
    int j = 0;
    int x1 = 0, x2 = 0;
    while (i < t1.size() && j < t2.size()) {
        int len = min(t1[i].r - t1[i].l + 1 - x1, t2[j].r - t2[j].l + 1 - x2);
        if (calc(t1[i].l + x1, t2[j].l + x2) < len)return false;
        if (t1[i].l + x1 + len - 1 == t1[i].r && t2[j].l + x2 + len - 1 == t2[j].r) {
            i++;
            j++;
            x1 = 0;
            x2 = 0;
            continue;
        }
        if (t1[i].l + x1 + len - 1 == t1[i].r) {
            x2 += len;
            x1 = 0;
            i++;
        } else {
            x1 += len;
            x2 = 0;
            j++;
        }
    }
    return true;
}
int main() {
    cin >> n;
    cin >> (s + 1);
    for (int i = 1; i <= n; i++) {
        cin >> father[i];
        if (father[i]) {
            gr.add(father[i], i);
        }
    }
    top[1] = 1;
    dfs1(1);
    dfs2(1);
    for (int i = 1; i <= n; i++) {
        tmp[i] = i;
    }
    sort(tmp + 1, tmp + 1 + n, cmp);
    for (int i = 1; i <= n; i++) {
        int x = tmp[i];
        if (vis[x])continue;
        vector<int> d;
        while (x != top[x]) {
            d.push_back(x);
            vis[x] = true;
            x = father[x];
        }
        vis[x] = true;
        d.push_back(x);
        for (int j = d.size() - 1; j >= 0; j--) {
            t[++len] = s[d[j]];
            zidx[d[j]] = len;
        }
        for (int j = 0; j < d.size(); j++) {
            t[++len] = s[d[j]];
            fidx[d[j]] = len;
        }
    }
    getsa();
    logv[0] = -1;
    for (int i = 1; i <= len; i++) {
        min_h[0][i] = h[i];
        logv[i] = logv[i >> 1] + 1;
    }
    for (int j = 1; j <= 18; j++) {
        for (int i = 1; i + (1 << j) - 1 <= len; i++) {
            min_h[j][i] = min(min_h[j - 1][i], min_h[j - 1][i + (1 << (j - 1))]);
        }
    }
    int q;
    cin >> q;
    while (q--) {
        int x, y;
        cin >> x >> y;
        vector<node> t1 = query(x, y);
        vector<node> t2 = query(y, x);
        if (check(t1, t2)) {
            cout << "YES" << '\n';
        } else {
            cout << "NO" << '\n';
        }
    }
    return 0;
}
全部评论
不是很懂 序列自动机 是什么东西，看起来代码中很简单有什么应用吗
点赞 回复 分享
发布于 04-19 22:23 浙江
https://ac.nowcoder.com/acm/contest/65051/D F原题啊 @牛客网技术团队
点赞 回复 分享
发布于 04-19 23:19 广东
气死了，G题调了半天一直wa 61%.然后实在没办法，试一下把底数从131改成std的13331，发现过的更少了。然后才发现一开始哈希数组想用自然溢出，dfs预处理的地方就没取模，后面发现要逆元才都改成long long。这个地方硬控我一小时
点赞 回复 分享
发布于 04-23 17:38 天津

相关推荐

11-25 19:33
南京理工大学 C++
C++选手秋招总结
秋招进行到现在终于能写总结了。完全没想到战线会拉这么长，过程会如此狼狈，不过更应该怪自己太菜了。好在所有的运气都用在了最后，也是有个去处。背景：双2本硕科班，无竞赛，本科一段研究所实习，硕士一段大厂暑期实习但无转正。技术栈是C++&nbsp;&amp;&nbsp;Golang，实习是客户端音视频（而且是鸿蒙端开发），简历两个C++项目一个Golang项目。主要投递岗位：后端，cpp软开，游戏服务端，测开，以及一些不拘泥于Java的岗位。从8月起总共投递123家公司，笔试数不清了，约面大约30家。offer/oc/意向：友塔游戏（第一个offer，面试体验很好，就是给钱好少南瑞继保（计算机科班点击就送（限男生），不...
乡土丁真真：佬很厉害，羡慕~虽然我还没有到校招的时候，也想讲一下自己的看法：我觉得不是CPP的问题，佬的背书双2，技术栈加了GO，有两段实习。投了123，面了30.拿到11个offer。这个数据已经很耀眼了。这不也是CPP带来的吗？当然也不止是CPP。至少来说在这个方向努力过的也会有好的结果和选择。同等学历和项目选java就会有更好的吗？我个人持疑问态度。当然CPP在方向选择上确实让人头大，但是我觉得能上岸，至于最后做什么方向，在我看来并不重要。至于CPP特殊，有岗位方向的随机性，java不是不挑方向，只是没得选而已。也希望自己以后校招的时候能offer满满
25届秋招总结
点赞 评论 收藏
分享
11-26 11:02
门头沟学院 电气工程师
上班苦还是上学苦
看到这个话题挺有意思的，不过二选一感觉有点武断了，为什么都是苦呢，就不能有点甜头么哈哈。我觉得这两个都不能说是苦吧，都是不一样的人生阶段，甚至还有不一样的乐趣，可能因为我比较乐观，也可能因为我比较幸运，因为这两个阶段遇到的都是比较好的一面。给大家分享一下我的感受吧。1、我很幸运，上班和上学都不算苦上大学我没遇到恶心的导师，反而是鼓励我们去实习，生活和学习中也给我很大帮助。目前在北方华创工作也没有遇到领导pua、加班文化之类的，反而是每天的工作都很充实又有挑战，每天都感觉自己在快速成长，不是参与公司培训，就是在工作中实践学习。每做一个项目都有新经验的积累，特别是项目复盘的时候，最能感受自己成长的...
不知名王同学：非要在两坨💩里面吃一坨是吧
美的集团公司福利 136人发布 上班苦还是上学苦呢？
点赞 评论 收藏
分享
11-18 16:08
福州大学 Java
扣税比我总包都高一大截
大佬们太狠了
影流之主：干10年不被裁，我就能拿别人一年的钱了，日子有盼头了
点赞 评论 收藏
分享
11-28 20:35
苏州大学 IC验证工程师
如何评价
qz鹿：*** 祝他毕业就失业
点赞 评论 收藏
分享
11-26 15:16
上海交通大学 商务渠道
中信银行面试记录
面试流程：无领导小组讨论：10人一组，分成两个5人小组进行辩论，时长约30分钟。形式较为轻松，但需要积极发言，展现个人见解。半结构化面试：紧随无领导面试后，以群面形式进行，由3位面试官主持，其中可能包括人事老总。面试前需准备好对中信银行的深入了解。注意要点：女生建议携带平底鞋或低跟鞋，以满足长时间站立或行走的需求。了解中信银行及其核心价值观，熟悉股份制银行与国有银行的区别，以及自己对银行工作的看法和服务理念。在无领导小组讨论中要敢于表达自己的观点，同时保持团队合作精神。对于服务与销售的重要性问题，强调服务是销售的前提，良好的服务能增强客户信任，促进销售成功。
查看5道真题和解析 非技术面试记录
点赞 评论 收藏
分享
评论
17
1
分享

全站热榜

正在热议
# 拼多多求职进展汇总 #
238988次浏览 2044人参与
# 实习，投递多份简历没人回复怎么办 #
2444467次浏览 34770人参与
# 阿里云管培生offer #
64215次浏览 1764人参与
# 25届秋招总结 #
418879次浏览 4204人参与
# ai智能作图 #
32727次浏览 403人参与
# 地方国企笔面经互助 #
7195次浏览 17人参与
# 北方华创开奖 #
67648次浏览 555人参与
# 虾皮求职进展汇总 #
97128次浏览 789人参与
# 我在牛爱网找对象 #
75084次浏览 556人参与
# 机械求职避坑tips #
24051次浏览 251人参与
# 发工资后，你做的第一件事是什么 #
9873次浏览 45人参与
# 25届机械人为了秋招做了哪些准备？ #
26677次浏览 365人参与
# 投格力的你，拿到offer了吗？ #
47723次浏览 337人参与
# 我的实习求职记录 #
6139250次浏览 84047人参与
# 投递实习岗位前的准备 #
1192704次浏览 18502人参与
# 机械人怎么评价今年的华为 #
158268次浏览 1354人参与
# 实习想申请秋招offer，能不能argue薪资 #
36968次浏览 310人参与
# 实习与准备秋招该如何平衡 #
725285次浏览 8566人参与
# 华为工作体验 #
112175次浏览 869人参与
# 如果再来一次，你还会选择这个工作吗？ #
118117次浏览 1162人参与
# 在职场上，你最讨厌什么样的同事 #
6335次浏览 92人参与
# 国央企笔面经互助 #
88782次浏览 897人参与
牛客网
牛客企业服务