拓扑排序详解（梅开二度之dfs版判环 + dfs版按字典序输出拓扑路径 + dfs版输出全部拓扑路径

什么是拓扑排序？

先穿袜子再穿鞋，先当孙子再当爷。这就是拓扑排序！

拓扑排序说白了其实不太算是一种排序算法，但又像是一种排序（我是不是说了个废话qwq）

他其实是一个有向无环图（DAG, Directed Acyclic Graph的所有顶点的线性序列，该序列需要满足两个条件：

  • 每个节点只能出现一次
  • 若存在一条A到B到路径，则在拓扑序列中A必然出现在B前面

而有向无环图才具有拓扑排序，非DAG图则没有拓扑排序一说

先看一道拓扑排序的水题趴(>_<)

UVa 10305 - Ordering Tasks

题意：

有n个任务要做，有m个要求，每个要求有两个数x，y，要求x必须在y之前执行，让你输出一种执行任务的序列

这里窝给出两种方法，一种dfs，一种bfs，两种建图方法，一种邻接链表，一种链式前向星

再看一道稍微有点变化的拓扑排序

1089.拓扑排序

题意：

给定一个有向图，若存在环，输出IMPOSABLE，否则输出一行用一个空格隔开的拓扑排序的结果，若存在多个结果，输出字典序最小的。

既需要判断是否有环也需要输出字典序最小的

同样的，窝给出两种方法，一种dfs，一种bfs，来判环以及输出字典序最小

bfs版拓扑排序

问题1:

主要思想就是找出所有入度为0的点，给他们扔进队列里面，然后对对列的元素进行如下操作：取队首赋为now，扔队首，遍历now的所有后继节点，并让他们的入度减1，同时进行判断入度是否减到了0，如果到0了，就扔进对列，一直循环到对列为空结束

如果需要按字典序输出，就用优先队列

邻接链表建图：

使用vector，注意要每次初始化vector

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, now;
vector<vector<int> >tr;
int in[MAX];
queue<int>q;
bool vis[MAX];

void topsort(){
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0)q.push(i);//找到所有入度为0的点，入队
    }
    while (!q.empty()) {
        now = q.front();q.pop();//取队首，记得pop
        if(vis[now])continue;//如果访问过就跳过
        vis[now] = 1;//没访问就标记一下
        cout<<now<<' ';//输出
        for(int i = 0; i < tr[now].size(); ++i){
            int v = tr[now][i];
            --in[v];//入度减一
            if(in[v] == 0)q.push(v);//如果入度为0，入队
        }
    }
    cout<<endl;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        mem(in, 0);
        mem(vis, 0);
        tr = vector<vector<int> >(n + 1);//初始化
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            tr[a].push_back(b);//b为a的后继节点，就无脑塞
            ++in[b];//b的入度加一
        }
        topsort();
    }
    return 0;
}

链式前向星建图：

主要的思想没有变化，只不过用的是链式前向星建图，相当于板子而已，写多了就习惯了，再加上如果怕vector被卡的话就采用链式前向星

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
queue<int>q;

void init(){//初始化
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){//建图
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void topsort(){
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0)q.push(i);
    }
    while (!q.empty()) {
        now = q.front();q.pop();
        if(vis[now])continue;
        vis[now] = 1;
        cout<<now<<' ';
        for(int i = head[now]; i != -1; i = tr[i].next){
            int v = tr[i].to;
            --in[v];
            if(in[v] == 0)q.push(v);
        }
    }
    cout<<endl;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        topsort();
    }
    return 0;
}

问题2:

如何判环呢？

我们只需要记录输出的数字的个数是否等于n即可

如何输出字典序最小呢？

只需要将queue换成priority_queue即可

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, tot, x, y, now;
struct ran{
    int to, next;
}tr[MAX];
int in[1005];
int head[MAX];
bool vis[MAX];
int ans[1005];
int num;
priority_queue<int, vector<int>, greater<int> >q;//优先队列

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void topu(){
    tot = 0;
    while (!q.empty()) {
        now = q.top();q.pop();
        if(vis[now])continue;
        ++tot;//记录数量
        vis[now] = 1;
        ans[++num] = now;
        for(int i = head[now]; i != -1; i = tr[i].next){
//            cout<<tr[i].to;
            --in[tr[i].to];
            if(in[tr[i].to] == 0)q.push(tr[i].to);
        }
    }
}


int main(){
    io;
    n = IntRead();
    m = IntRead();
    mem(head, -1);
    mem(tr, -1);
    for(int i = 1; i <= m; ++i){
        x = IntRead();
        y = IntRead();
        built(x, y);
        ++in[y];
    }
    for(int i = 1; i <= n; ++i){
        if(in[i] == 0){
            q.push(i);
        }
    }
    topu();
    if(tot == n){//如果输出的数的数量等与n，就说明没有环
        for(int i = 1; i <= n; ++i){
            i == 1 ? cout<<ans[i] : cout<<' '<<ans[i];
        }
        cout<<endl;
    }
    else cout<<"IMPOSABLE\n";
    return 0;
}

dfs版拓扑排序

问题1:

之前写拓扑排序都是用的bfs的方法，没寻思dfs还可以写，直到我做了一下oj的1089，判环的时候发现可以用dfs判环，然后我就好奇如何用dfs进行拓扑排序、如何按字典序输出拓扑序列、如何将所有的拓扑序列都输出，发现网上很少有教这些的，就寻思自己写一写，于是就有了这篇博客o(≧v≦)o

刚开始觉得用dfs写拓扑排序很复杂，这他么的dfs能怎么排？

要从入度为0出发么？

如果有多个入度为0的点，每个都dfs一遍么，那他们会不会乱套？

后来学会了以后感觉简直不可思议，真的是奈何自己没文化，一句wc行天下

首先我们讨论一下拓扑排序的性质，对于一个图，他可能会有好多种拓扑排序，但他们满足一个规律：那就是如果存在有向边u->v, 那么结点u必须排在v之前（前驱）。同时这种性质具有传递性，也就是说如果同时存在v->t, 那么满足u在t之前。同样的，如果u和v两个结点在图中并不满足这种性质，那么谁在前谁在后就无所谓了。正是利用这个规则，我们进行dfs的顺序是无所谓的。

为何？因为我们从root结点开始dfs一遍，可以找到所有的必须在这个root结点之后的点，那么我们就满足了拓扑序的规则了，那么我们无论先dfs(u)还是先dfs(v), 都不会违背这个规则（除非有环），那么同时我们只要按照某种合理的方式存储所有这些点，那么他们就是拓扑序了。

什么是合理的方式？栈！考量一个dfs(u), 在它结束该退出时，它代表它的结点u。在dfs递归中，什么点会最先exit？没有后继结点的点（或者后继已入栈的点）！那么把所有点分成两个集合，一个是待处理的点集D，一个是已拓扑排序后的点集A，当且仅当D中某个点没有后继结点（或该后继结点已经加入了点集A中）时，它可以从D转移到A，而dfs的回溯方式，恰恰就自动实现了这样的功能。 结合代码更容易体会。

不需要判环，输出一种拓扑排序（链式前向星法

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
stack<int>s;

void init(){
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void dfs(int u){
    vis[u] = 1;//标记一下这个点来过
    for(int i = head[u]; i != -1; i = tr[i].next){
        int v = tr[i].to;
        if(!vis[v])dfs(v);//下一个点如果没来过，就dfs下一个点
    }
    s.push(u);//搜完了就入栈
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        for(int i = 1; i <= n; ++i){
            if(!vis[i])dfs(i);
        }
        while (!s.empty()) {
            cout<<s.top()<<' ';s.pop();
        }
        cout<<endl;
    }
    return 0;
}

问题2:

如何判环？

判环只是在dfs的基础上稍作修改，其最主要的是对vis数组的含义有所扩展，以及对下一个节点进行dfs判断

不判环对vis只代表该点也没有被访问，而现在vis有三个值，-1，0，1. -1代表已经访问过，但不是当前dfs访问的， 1表示访问过，且是当前的dfs访问的，意味着有环（u->v,v->t,t->u），0表示没访问过

dfs返回的是以root为根节点的后续有没有环，所以我们需要对每个点都去跑一遍dfs，当然，如果已经访问过了，就没必要去dfs他了

伪代码

//判断是否有环(true 没有; false 有)
bool dfs(u) {
    本趟节点标记;
    for(遍历以u为入弧的定点){
            if(是本趟节点）return false;
            else if(如果没访问过) {
                if(子节点有环)return false;
            }
        }
        //表示这个节点的到底都没有环
        倒着将沿途的节点加入拓扑队列    //因为这是递归的返回,就是到头回来的过程
        return true;
    }
bool topoSort(){
    for(遍历节点){
        if(没访问过）{
            if(有环) return false;
        }
    }
    //所有节点都没环
    return true;
}

两句if 可以合成为 
if(没访问过 && 有环)return false;

核心代码如下：

bool dfs(int u)
{
    vis[u] = 1;
    for (int i = head[u]; i; i = edge[i].next) {
        int v = edge[i].to;
        if (vis[v] == 1) return false;
        if (vis[v] == 0 && !dfs(v)) return false;
    }
    vis[u] = -1;
    s.push(u);
    return true;
}

bool topsort(){
    mem(vis, 0);
    for(int i = n; i >= 1; --i){
        if(!vis[i]){
            if(!dfs(i))return false;
        }
    }
    return true;
}

如何按照字典序输出呢？

我们输出的时候是通过栈输出的，栈是先进后出，所以要想字典序最小，只需要让大的先进去，小的后进去，所以我们采用邻接链表的方法存图，存完图以后对每一个root节点的后续节点从大到小进行排序，这样dfs的时候，顺着取后继节点的时候就是从大到小。然后我们for循环的时候，也是从n开始到1去循环即可

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, cnt;
vector<vector<int> >ma;
int vis[MAX];
stack<int>s;

bool cmp(int x, int y){
    return x > y;
}


bool dfs(int u){
    vis[u] = -1;
    for(int i = 0; i < ma[u].size(); ++i){
        if(vis[ma[u][i]] == -1)return false;
        else if(vis[ma[u][i]] == 0){
            dfs(ma[u][i]);
        }
    }
    vis[u] = 1;
    s.push(u);
    return true;
}

bool topsort(){
    mem(vis, 0);
    for(int i = n; i >= 1; --i){//从大的开始
        if(!vis[i]){
            if(!dfs(i))return false;
        }
    }
    return true;
}


int main(){
    n = IntRead();
    m = IntRead();
    ma = vector<vector<int> >(n + 1);//初始化
    for(int i = 1; i <= m; ++i){
        a = IntRead();
        b = IntRead();
        ma[a].push_back(b);
    }
    for(int i = 1; i <= n; ++i){//排序！
        sort(ma[i].begin(), ma[i].end(), cmp);
    }
    bool p = topsort();
    if(p == false)cout<<"IMPOSABLE\n";
    else {
        while (s.size() != 1) {
                cout<<s.top()<<" ";
                s.pop();
            }
            cout<<s.top()<<endl;
    }
    return 0;
}

输出所有的拓扑序列

就是一个dfs，每次dfs都让入度为0且没有标记的点 i 去更新其后继节点，然后将 i 放进ans数组中，然后标记一下，去dfs(num + 1)，回溯的时候，就把所有更新的点的入度都加回来，把 i 重新标记为0。

#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <stdlib.h>
#include <sstream>
#include <map>
#include <set>
using  namespace std;
#define inf 0x3f3f3f3f
#define MAX 200000 + 50
#define endl '\n'
#define seed 13331
#define mod 1000000000 + 7
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
typedef  long long ll ;
//不开longlong见祖宗！
//inline __int128 read(){__int128 x = 0, f = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-'){f = -1;}ch = getchar();}while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0';ch = getchar();}return x * f;}
//inline void print(__int128 x){if(x < 0){putchar('-');x = -x;}if(x > 9){print(x / 10);}putchar(x % 10 + '0');}
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}
inline void write(int x){if (x < 0) {x = ~x + 1; putchar('-');}if (x > 9){write(x / 10);}putchar(x % 10 + '0');}

int n, m, a, b, tot, now;
int head[MAX];
int in[MAX];
bool vis[MAX];
struct ran{
    int to, next;
}tr[MAX];
int ans[MAX];

void init(){
    mem(in, 0);
    mem(vis, 0);
    mem(tr, 0);
    mem(head, -1);
    tot = 0;
}

void built(int u, int v){
    tr[++tot].to = v;
    tr[tot].next = head[u];
    head[u] = tot;
}

void dfs(int num){
    if(num == n + 1){//如果数量到n+1，就输出
        for(int i = 1; i <= n; ++i){
            cout<<ans[i]<<' ';
        }
        cout<<endl;
    }
    for(int i = 1; i <= n; ++i){
        if(!in[i] && !vis[i]){//入度为0，且没被标记过
            int u = i;
            for(int j = head[u]; j != -1; j = tr[j].next){
                --in[tr[j].to];//遍历所有后继节点
            }
            vis[u] = 1;//标记一下点i
            ans[num] = u;//把他放进ans数组
            dfs(num + 1);//继续搜
            for(int k = head[u]; k != -1; k = tr[k].next){
                ++in[tr[k].to];
            }//把入度更新回来
            vis[u] = 0;//取消标记
        }
    }
    return;
}

int main(){
    io;
    while (cin>>n>>m && (n + m)) {
        init();
        for(int i = 1; i <= m; ++i){
            cin>>a>>b;
            built(a, b);
            ++in[b];
        }
        dfs(1);
    }
    return 0;
}
全部评论

相关推荐

11-21 15:06
已编辑
中国矿业大学（北京） 后端
【简历】25届一本JAVA简历：秒杀真不能做到校招主项目了
注：为保证用户信息安全，姓名和学校等信息已经进行同层次变更，内容部分细节也进行了部分隐藏另外：我们出这一系列校招简历指导的原因，就是看很多学生被忽悠，没有先定位大厂、中厂还是小公司，导致没有面试机会。&nbsp;我们不放任何的广告和品牌名，完全是反馈牛客社区。大家也不要私信，现在比较忙，没空帮大家改简历。简历总体说明&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;校招的第一法则就是必须要确定校招层次。&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;开发岗分为大中小厂，不同的层次对学校背景、时间点、项目和考点的要求都不太一样，所以必须要确定就业的层次。&nbsp;这是一份苏州某一本大学的JAVA简历。之前，我们一直强调校招首先要确定层次，一本的25届学生校招的主体就是中厂。并且现在秋招...
投递牛客等公司10个岗位 > 你的秋招简历被谁挂了？ 你的简历改到第几版了
点赞 评论 收藏
分享
11-22 17:55
河南工学院 光传输工程师
点赞 评论 收藏
分享
10-01 18:32
杭州文澜中学 数字IC前端设计
点赞 评论 收藏
分享
不愿透露姓名的神秘牛友
11-20 19:57
已编辑
求校招Offer比较：某大厂VS某中厂
某大厂 golang工程师 23.0k*16.0, 2k房补，年终大概率能拿到
点赞 评论 收藏
分享
1 收藏 评论
分享

全站热榜

正在热议
# 25届秋招总结 #
303473次浏览 2693人参与
# 如果不工作真的会快乐吗 #
59485次浏览 519人参与
# 百度开奖 #
164013次浏览 982人参与
# 地方国企笔面经互助 #
3897次浏览 11人参与
# 美团求职进展汇总 #
1328354次浏览 12453人参与
# 选完offer后，你后悔学本专业吗 #
20195次浏览 144人参与
# 阿里云管培生offer #
17874次浏览 297人参与
# 正在实习的你，几点下班 #
52136次浏览 391人参与
# 国央企薪资爆料 #
8687次浏览 69人参与
# 如何一边实习一边秋招 #
992675次浏览 12640人参与
# 提前批简历挂麻了怎么办 #
146599次浏览 1948人参与
# 学历or实习经历，哪个更重要 #
51321次浏览 402人参与
# 海康威视求职进展汇总 #
399126次浏览 3406人参与
# 米哈游求职进展汇总 #
176171次浏览 1458人参与
# 求职遇到的搞笑事件 #
70914次浏览 577人参与
# 投递实习岗位前的准备 #
1179886次浏览 18398人参与
# 面试体验感最好的是哪家？ #
85183次浏览 846人参与
# 实习生应该准时下班吗 #
167506次浏览 1159人参与
# 得物求职进展汇总 #
66409次浏览 682人参与
# 网申一定要掌握的小技巧 #
5358次浏览 53人参与
# 招聘要求与实际实习内容不符怎么办 #
10322次浏览 273人参与
# 0offer是寒冬太冷还是我太菜 #
899117次浏览 8015人参与
牛客网
牛客企业服务