2020-11-13 17:17 已编辑天津大学 C++

关注

树上dfs序小专题

说在前面的

$dfs$ 和欧拉序都是非常有力的工具，我们应该熟练的运用两者。而且 $dfs$ 序也不必局限于树上的 $dfs$ 序，其实一般图也有 $dfs$ 序，有兴趣的朋友可以参考 $tarjan$ 算法。

以下的 $dfs$ 序，全部指树上的 $dfs$ 序， $dfs$ 序即使在树上，仍然不是唯一的。
以下的 $size_u$ ，全部指以 $u$ 为根，子树的大小。

dfs 序

引入

如何判断 $u,v$ 是否有所属关系，也就是 $v\in subtree(u)$ ，多次询问。我们发现我们并不能把每个节点的 $subtree$ 记录下来，这使我们不太好查询是否 $v\in subtree$ 。

我们可以考虑模拟 $dfs$ 的过程，先遍历所有儿子，然后才去遍历其他子树。那么我们发现，如果按照遍历顺序，在第一次遍历到这个节点时，将该节点压入数组。那么节点在新数组的位置叫做这个节点的 $dfs$ 序。由此我们得到了一棵树的 $dfs$ 序序列，但是序列又有什么性质呢？

性质

$dfs$ 的性质是非常多，而且非常重要的。这里选取一些常用的进行讲解。

一个子树的 $dfs$ 序一定是连续的，而且节点 $u$ 的子树大小也就是 $dfs$ 序中，从 $u$ 开始，到后面连续的 $size_{u}$ 个元素结束，这些元素全是属于 $u$ 的子树的。这个可以通过分析 $dfs$ 的过程得到，因为我们要遍历完一个子树才会回溯，所以在没有遍历完 $size_u$ 个元素时，是不会退出的。

图片说明

$dfs$ 序列是由连续的链构成的，而且每一条链上的节点深度由浅到深依次排列。这个也可以通过分析 $dfs$ 的过程得到。

欧拉序(括号序列)

这个欧拉序和 $dfs$ 序其实有非常多的共同点，在构造时的唯一区别是， $dfs$ 是在只第一次访问时加入数组中。而欧拉序还要在回溯时，把该节点压入数组。如果我们把第一次访问，当作是加入左括号 $($ ，回溯看作是加入右括号 $)$ 。那么最后 $dfs$ 遍历完整个树，最后得到的就是一个括号序列。

性质

由于欧拉序维护了出栈的标记，所以相比 $dfs$ 序，更加强大，维护的东西也更加多。

每个节点会出现两次。因为入栈出栈都维护了。
相邻两个节点的深度相差 $1$ 。 $dfs$ 的访问是连续的，回溯也是连续的，这个还是比较显然的。
可以维护树上路径。这个就比较有意思了。我们把第一次进入数组的位置命名为 $st_u$ ，第二次称之为 $ed_u$ 。那么 $path_{u,v}(st_u<st_v)$ 是要分类讨论的。
- $lca(u,v) = u$ 。那么 $path_{u,v}$ 从 $st_u$ 到 $st_v$ 中只出现了一次的元素。为什么是只出现一次呢，由于 $v\in subtree_u$ 所以出现两次的，是其它子树的元素，与 $path_{u,v}$ 无关。
- $lca(u,v)\neq u$ 。那么 $path_{u,v}$ 是从 $ed_u$ 到 $st_v$ 中只出现一次的元素，和 $lca(u,v)$ 组成的。出现两次的元素一定是 $lca(u,v)$ 的其它子树中的元素，而 $lca(u,v)$ 先于 $u$ 遍历，而 $subtree_v$ 还没遍历完，所以 $ed_{lca(u,v)}$ 还没有进入数组，所以要把 $lca(u,v)$ 单独加入路径中。这个也是树上莫队算法的一个依据。

图片说明

维护祖先儿子关系。同 $dfs$ 序的维护。而且我们还发现这个节点的左括号到右括号中的所有元素都是子树元素，而且左右括号可以完美匹配 $\underbrace{(()()(()))}_{subtree}$ 。

例题

出于写博客服务于大家和自己，这里先将一点关于 $dfs$ 序的基础题，最后再讲讲牛客的例题（谢谢理解）。

Tree Queries

题意

给你一个以 $1$ 为根的有根树，每回询问 $k$ 个节点 ${v_1,v_2..v_k}$ 。求出是否有一条以根节点为一端的链，使得询问的每个节点到此链的距离均 $\le 1$ 。只需输出可行性, 无需输出方案。

分析

无论是哪种方案，想要使链到节点的距离 $\le 1$ 。那么只有三种可能。

经过父亲。
经过自己。
经过一个直接的儿子。

但是我们发现这三种其实都必须经过父亲。所以把 $v_i$ 的父亲的 $dfs$ 序由小到大排序，最后判断后一个是不是当前节点的儿子，就可以了，这个可以通过 $dfs$ 序做到。复杂度为 $O(n\log n)$ 。

代码

#include<bits/stdc++.h>
using namespace std;
int read() {
    int x = 0,f = 0;char ch = getchar();
    while(!isdigit(ch)) {if(ch=='-')f=1;ch=getchar();}
    while(isdigit(ch)) {x = x * 10 + ch - '0';ch=getchar();}
    return f?-x:x;
}
const int N = 2e5+100;
int n,m,dep[N],fa[N],dfn[N],Id,st[N],si[N];
vector<int> G[N];
bool cmp(int x,int y) {return dep[x] < dep[y];}
void dfs(int x,int f,int de) {
    dep[x] = de;dfn[x] = ++Id;si[x]=1;fa[x] = f;
    for(auto y:G[x]) {if(y == f) continue;dfs(y,x,de+1);si[x]+=si[y];}    
}
int main()
{
    n = read();m = read();
    for(int i = 1;i < n;i++) {
        int x = read(),y = read();
        G[x].push_back(y);G[y].push_back(x);
    }
    dfs(1,1,1);
    while(m--) {
        int sum = read(),check = 0;
        for(int i = 1;i <= sum;i++) st[i] = fa[read()];
        sort(st+1,st+1+sum,cmp);
        for(int i = 2;i <= sum;i++) {
            if(dfn[st[i]] >= dfn[st[i-1]] && dfn[st[i]] <= dfn[st[i-1]] + si[st[i-1]] - 1) continue;
            check = 1;
        }
        !check?puts("Yes"):puts("No");
    }
}

Military Problem

分析

这个就是模拟 $dfs$ 的过程就行了，判断可以直接输出 $dfs$ 序对应的元素。输出前判断一下 $k$ 于 $size$ 的关系就好了。小细节，如果要用链式前向星存边，那么根据遍历顺序，应该倒着建边，这个稍微分析一下就好了。最后总复杂度为 $O(n)$ 。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1000;
int ecnt,si[N],id[N],pos[N],head[N],n,Id,to[N];
struct Edge {int to,nxt;}e[N];
int read() {int x;scanf("%d",&x);return x;}
void add(int x,int y) {e[++ecnt].to = y;e[ecnt].nxt = head[x];head[x] = ecnt;}
void dfs(int x) {
    pos[id[x] = ++Id] = x;si[x] = 1;
    for(int i = head[x];i;i=e[i].nxt) dfs(e[i].to),si[x] += si[e[i].to];
}
int main() {
    n = read();int Q = read();
    for(int i = 2,fa;i <= n;i++) to[i] = read();
    for(int i = n;i > 1;i--) add(to[i],i); 
    dfs(1);
    while(Q--) {
        int rt = read(),k = read();
        if(si[rt] < k) puts("-1");
        else printf("%d\n",pos[id[rt] + k - 1]);
    }
}

选点

分析

不太一样的 $dfs$ 序，但是核心思想没有区别。由于我们选出来的点要满足 $w_{root} < w_{rson} < w_{lson}$ 。那么我们可以先遍历 $root->rson->lson$ 这样的顺序遍历，这样把树映射到序列上，这样问题就形式化了。求问一个序列的最长上升子序列。这样就可以随便做了，可以用数据结构优化一下，总复杂度为 $O(n\log n)$ 。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1000;
int read() {int x;scanf("%d",&x);return x;}
int n,lc[N],rc[N],id[N],Id,pos[N],f[N],ans,w[N],t[N];
void dfs(int x) {
    pos[id[x] = ++Id] = x;
    if(rc[x]) dfs(rc[x]);if(lc[x]) dfs(lc[x]);
}
void upd(int x,int v) {for(int i = x;i <= n;i += i & -i) t[i] = max(t[i],v);}
int ask(int x) {int tot = 0;for(int i = x;i;i -= i & -i) tot = max(tot,t[i]);return tot;}
int res[N];
int main() {
    n = read();
    for(int i = 1;i <= n;i++) res[i] = w[i] = read();
    for(int i = 1;i <= n;i++) lc[i] = read(),rc[i] = read();
    sort(res + 1,res + 1 + n);
    int cnt = unique(res + 1,res + 1 + n) - res - 1;
    for(int i = 1;i <= n;i++) w[i] = lower_bound(res + 1,res + cnt + 1,w[i]) - res;
    dfs(1);
    for(int i = 1;i <= n;i++) {
        f[i] = ask(w[pos[i]] - 1) + 1;
        ans = max(f[i],ans);
        upd(w[pos[i]],f[i]);
    }
    printf("%d\n",ans);
    return 0;
}

Tree Requests

题意

给定一个以 $1$ 为根的 $n$ 个节点的树，每个点上有一个字母 $a$ 到 $z$ ，每次询问 $a,b$ ，查询以 $a$ 为根的子树内深度为 $b$ 的节点上的字母重新排列之后是否能构成回文串。

分析

关于这题，我并没有非常好的基于 $dfs$ 序的做法，抱歉。这里提供一种树上启发式合并的做法。构成回文串的字母应该满足 $\sum_{i='a'}^{'z'}[sum_i\bmod 2] \le 1$ 。 $sum_i$ 表示 $i$ 这个字符出现的次数。那么根据每个元素只会在跳轻边时合并，而任何一个节点到根路径上只有 $\log n$ 条轻边，那么总复杂度为 $O(n\log n)$ 。

代码

#include<bits/stdc++.h>
using namespace std;
const int M = 5e5+1000;
struct Query{
    int de,id;
};
int n,m;
vector<int> G[M];
vector<Query> Q[M];
int L[M],R[M],id[M],T;
int dep[M],son[M],si[M];
int check[M],ans[M];
char A[M];
void dfs(int u,int d) {
    L[u] = ++T;dep[u] = d;
    id[T] = u;son[u] = 0;si[u] = 1;
    for(int i = 0;i < G[u].size();i++) {
        int v = G[u][i];
        dfs(v,d+1);
        if(si[v]>si[son[u]]) son[u] = v;
        si[u] += si[v];
    }
    R[u] = T;
}
void add_point(int x) {
    int r = A[x] - 'a',d = dep[x];
    check[d] ^= (1<<r);
}
void add_tree(int x) {
    for(int i = L[x];i <= R[x];i++) add_point(id[i]);
}
void solve(int x) {
    for(int i = 0;i < G[x].size();i++) {
        int y = G[x][i];
        if(y == son[x]) continue;
        solve(y);add_tree(y);
    }
    if(son[x]) solve(son[x]);
    for(int i = 0;i < G[x].size();i++) {
        int y = G[x][i];
        if(y == son[x]) continue;
        add_tree(y);
    }
    add_point(x);
    for(int i = 0;i < Q[x].size();i++) {
        int d = Q[x][i].de,r = check[d],id = Q[x][i].id;
        ans[id] = (r==(r&-r));
    }
}
int main() {
    scanf("%d%d",&n,&m);
    for(int i = 2,f;i <= n;i++) {
        scanf("%d",&f);
        G[f].push_back(i);
    }
    dfs(1,1);
    scanf("%s",A+1);
    for(int i = 1;i <= m;i++) {
        int x,d;
        scanf("%d%d",&x,&d);
        Q[x].push_back((Query){d,i});
    }
    solve(1);
    for(int i = 1;i <= m;i++) {
        if(ans[i]) puts("Yes");
        else puts("No");
    }
    return 0;
}

我们对于一个树上选一些节点使他们的联通的代价最小。这个问题，我们可以按 $dfs$ 序由大到小排序，这样依次联接是没有重复路径的。这个可以手摸一下，也可以通过 $dfs$ 的性质得到。那么我们现在要处理的就是，如果删除和添加一个节点。我们考虑到，删除一个节点，那么这个节点左右两个元素的 $dfs$ 序仍然是连续的，所有我们可以考虑一个元素的贡献，为 $\frac{dis(L,x) + dis(x,R) - dis(L,R)}{2}$ 。那么我们就开个平衡树维护一下这个颜色的所有元素，动态的维护答案就好了。总的复杂度为 $O(n\log n)$ 。

小技巧，树上的节点 $(u,v)$ 的简单路径只有一条，其长度为 $d_u + d_v - 2 \times d_{lca(u,v)}$ 。
代码

#include<bits/stdc++.h>
using namespace std;
#define It set<int>::iterator
const int N = 1e5 + 1000;
int read() {int x;scanf("%d",&x);return x;}
struct Edge {int to,nxt;}e[N<<1];
int id[N],rid[N],col[N],Id,head[N],fa[N][21],dep[N],n,ecnt;
void add(int x,int y) {e[++ecnt] = (Edge){y,head[x]};head[x] = ecnt;}
int lca(int idx,int idy) {
    int x = rid[idx],y = rid[idy];
    if(dep[x] < dep[y]) swap(x,y);
    int k = dep[x] - dep[y];
    for(int i = 20;~i;i--) if((k >> i) & 1) x = fa[x][i];
    if(x == y) return x;
    for(int i = 20;~i;i--) if(fa[x][i] ^ fa[y][i]) x = fa[x][i],y = fa[y][i];
    return fa[x][0];
}
int dis(int idx,int idy) {
    int x = rid[idx],y = rid[idy];
    return (dep[x] + dep[y] - 2 * dep[lca(idx,idy)]);
}
void dfs(int x,int f) {
    fa[x][0] = f;rid[id[x] = ++Id] = x;
    for(int i = 1;i <= 20;i++) fa[x][i] = fa[fa[x][i-1]][i-1];
    for(int i = head[x];i;i=e[i].nxt) {
        int y = e[i].to;if(y == f) continue;
        dep[y] = dep[x] + 1;dfs(y,x);
    }
}
struct MST {
    set<int> s;int sum;
    void add(int x) {
        s.insert(x);It it = s.find(x);
        int L = 0,R = 0;
        ++it;if(it != s.end()) R = *it;
        --it;if(it != s.begin()) --it ,L = *it;
        if(L && R) sum -= dis(L,R);
        if(L) sum += dis(L,x);if(R) sum += dis(x,R);
    }
    void del(int x) {
        It it = s.find(x);
        int L = 0,R = 0;
        ++it;if(it != s.end()) R = *it;
        --it;if(it != s.begin()) --it ,L = *it;
        if(L && R) sum += dis(L,R);
        if(L) sum -= dis(L,x);if(R) sum -= dis(x,R);
        it = s.find(x);s.erase(it);
    }
    int ans() {return (sum + dis(*s.begin(),*s.rbegin())) / 2;}
}A[N];

int main() {
    n = read();
    for(int i = 1,x,y;i < n;i++) {
        x = read();y = read();
        add(x,y);add(y,x);
    }    
    dfs(1,0);
    for(int i = 1;i <= n;i++) {
        col[i] = read();A[col[i]].add(id[i]);
    }
    int Q = read();
    while(Q--) {
        char ch[10];scanf("%s",ch + 1);
        if(ch[1] == 'U') {
            int x = read(),y = read();
            A[col[x]].del(id[x]);
            col[x] = y;
            A[col[x]].add(id[x]);
        }
        else {
            int x = read();
            if(A[x].s.empty()) puts("-1");
            else printf("%d\n",A[x].ans());
        }
    }
}

求和 & Propagating tree

由于这两道题，没有什么本质上的区别。这里就把思路呈现出来。

分析

要求维护两个操作，查询单点和修改子树。我们可以直接用线段树在 $dfs$ 序乱搞，也可以转化为差分之后用树状数组维护。而 $\text{Propagating tree}$ 这道题，我们用奇偶分个组，也就做完了。

这里有个小技巧，一般对于链上查询，都可以差分成子树修改。虽然这里没有用到，但是我认为这个还是非常重要的。因为维护 $dfs$ 序，比链上操作要简单的多。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1000;
int ecnt,L[N],R[N],head[N],n,rt,Id;
struct Edge {int to,nxt;}e[N << 1];
int read() {int x;scanf("%d",&x);return x;}
void add(int x,int y) {e[++ecnt].to = y;e[ecnt].nxt = head[x];head[x] = ecnt;}
void dfs(int x,int f) {
  L[x] = ++Id;
  for(int i = head[x];i;i=e[i].nxt) if(e[i].to ^ f) dfs(e[i].to,x);
  R[x] = Id;
}
int val[N],t[N << 2];
void update(int u,int l,int r,int pos,int k) {
  if(l == r) {t[u] += k;return;}
  int mid = l + r >> 1;
  if(pos <= mid) update(u << 1,l,mid,pos,k);
  else update(u << 1 | 1,mid + 1,r,pos,k);
  t[u] = t[u << 1] + t[u << 1 | 1];
}
int ask(int u,int l,int r,int L,int R) {
  if(l > R || r < L) return 0;
  if(L <= l && r <= R) return t[u];
  int mid = l + r >> 1;
  return (ask(u << 1,l,mid,L,R) + ask(u << 1 | 1,mid + 1,r,L,R));
}
int main() {
  n = read();int Q = read();rt = read();
  for(int i = 1;i <= n;i++) val[i] = read();
  for(int i = 1,a,b;i < n;i++) {
      a = read();b = read();
      add(a,b);add(b,a);
  }
  dfs(rt,0);
  for(int i = 1;i <= n;i++) update(1,1,n,L[i],val[i]);
  while(Q--) {
      int opt = read();
      if(opt == 2) {
          int x = read();
          printf("%d\n",ask(1,1,n,L[x],R[x]));
      }
      else {
          int x = read(),y = read();
          update(1,1,n,L[x],y);
      }
  }
}
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1000;
int ecnt,L[N],R[N],head[N],n,Id;
bool col[N];
struct Edge {int to,nxt;}e[N << 1];
int read() {int x;scanf("%d",&x);return x;}
void add(int x,int y) {e[++ecnt].to = y;e[ecnt].nxt = head[x];head[x] = ecnt;}
void dfs(int x,int f,int c) {
  L[x] = ++Id;col[x] = c;
  for(int i = head[x];i;i=e[i].nxt) if(e[i].to ^ f) dfs(e[i].to,x,1 - c);
  R[x] = Id;
}
int val[N];
struct SegmentTree {
  int t[N << 2];
  void update(int u,int l,int r,int pos,int k) {
      if(l == r) {t[u] += k;return;}
      int mid = l + r >> 1;
      if(pos <= mid) update(u << 1,l,mid,pos,k);
      else update(u << 1 | 1,mid + 1,r,pos,k);
      t[u] = t[u << 1] + t[u << 1 | 1];
  }
  int ask(int u,int l,int r,int L,int R) {
      if(l > R || r < L) return 0;
      if(L <= l && r <= R) return t[u];
      int mid = l + r >> 1;
      return (ask(u << 1,l,mid,L,R) + ask(u << 1 | 1,mid + 1,r,L,R));
  }    
}T[2];
int main() {
  n = read();int Q = read();
  for(int i = 1;i <= n;i++) val[i] = read();
  for(int i = 1,a,b;i < n;i++) {
      a = read();b = read();
      add(a,b);add(b,a);
  }
  dfs(1,0,1);
  n++;
  while(Q--) {
      int opt = read();
      if(opt == 2) {
          int x = read();
          printf("%d\n",val[x] + T[col[x]].ask(1,1,n,1,L[x]) - T[1-col[x]].ask(1,1,n,1,L[x]));
      }
      else {
          int x = read(),y = read();
          T[col[x]].update(1,1,n,L[x],y);
          T[col[x]].update(1,1,n,R[x] + 1,-y);
      }
  }
}

[USACO19DEC]Bessie's Snow Cow P

个人觉得不错的一道题目，比较综合，要考虑 $dfs$ 序上的差分，建议画个图理解一下。

分析

我们查询答案时，我们有两种答案。一是，全部覆盖了子树的答案，二是，只覆盖了一部分子树的答案。所以我们可以对这两种答案分别开一个树状数组维护。而修改操作就可以对每个颜色开一个 $set$ ，每次修改到他的父亲，那么它的贡献就可以减去。那么总复杂度为 $O(n\log n)$ 。

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100,inf = 0x3f3f3f3f;
#define ll long long 
int read() {int x;scanf("%d",&x);return x;}
struct Edge {int to,nxt;}e[N << 1];
set<int> s[N];
#define It set<int>::iterator
int n,head[N],ecnt,id[N],rid[N],Id,si[N];
void add(int x,int y) {e[++ecnt]=(Edge){y,head[x]};head[x] = ecnt;}
struct Bit {
    ll t[N];
    void upd(int a,ll d) {for(int i = a;i <= n;i += i & -i) t[i] += d;}
    ll ask(int a) {ll tot = 0;for(int i = a;i;i -= i & -i) tot += t[i];return tot;}
}A,B;
void dfs(int x) {
    rid[id[x] = ++Id] = x;si[x] = 1;for(int i = head[x];i;i = e[i].nxt) {
        int y = e[i].to;if(id[y]) continue;dfs(y); si[x] += si[y];
    }
}
void upd(int x,int d) {
//    cout << x << " " << d << endl;
    A.upd(id[x],d);
    A.upd(id[x] + si[x],-d);
    B.upd(id[x],si[x] * d);
}
bool in(int a,int b) {return si[a] + id[a] <= si[b] + id[b];}
int main() {
    n = read();int Q = read();
    for(int i = 1,a,b;i < n;i++) {
        a = read();b = read();
        add(a,b);add(b,a);
    }
    dfs(1);
//    cout << "debug1 " << endl;
    while(Q--) {
        int opt = read();
        if(opt == 1) {
            int x = read(),y = read();
            It it = s[y].lower_bound(id[x]);
            if(it != s[y].begin()) {
                It itl = it;itl--; 
                if(in(x,rid[*itl])) continue;
            }
            while(it != s[y].end() && (*it) <= si[x] + id[x] - 1) {
//                cout << (*it) << endl;
                upd(rid[(*it)],-1);s[y].erase(it++);
            }
            s[y].insert(id[x]);upd(x,1);
        }
        else {
            int x = read();
            ll ans = si[x] * A.ask(id[x]) + B.ask(id[x] + si[x] - 1) - B.ask(id[x]);
            printf("%lld\n",ans);
        }
    }
}

结语

$dfs$ 序强大在于它将一个树转化为一个序列，使我们的操作更加简便。其实还有许多题目可以用到 $dfs$ 序，而且像树链剖分这种算法就是基于 $dfs$ 序实现的。反正就是很重要了。

全部评论

推荐最新楼层

林思艺

绵阳东辰国际学校 C++

捕获良心蒟佬一枚

2 回复分享

发布于 2020-11-09 19:37

11-22 00:38

南京大学 Java

深度思考后拒绝了offer

接到offer的那天，我心中矛盾重重，虽然证明了我的能力，但我却不想做不喜欢的工作。经过深思熟虑，我决定拒绝这份看似不错的工作。未来的日子里，我希望能勇敢追求自己真正想做的事情。再过两个月我就25岁了，我不想为不喜欢的选择而后悔。春招见！

牛客创作赏金赛

点赞评论收藏

11-25 15:30

已编辑

麻城理工学校嵌入式软件开发

秋招真的有不焦虑的人吗？

最近又搬回宿舍了，在工位坐不住，写一写秋招起伏不断的心态变化，也算对自己心态的一些思考表演式学习从开始为实习准备的时候就特别焦虑，楼主一开始选择的是cpp后端，但是24届这个方向已经炸了，同时自己又因为本科非92且非科班，所以感到机会更加迷茫。在某天晚上用java写出hello world并失眠一整晚后选择老本行干嵌入式。理想是美好的，现实情况是每天忙但又没有实质性进展，总是在配环境，调工具，顺带还要推科研。而这时候才发现自己一直在表演式学习，徘徊在设想如何展开工作的循环里，导致没有实质性进展。现在看来当时如果把精力专注在动手写而不是两只手端着看教程，基本功或许不会那么差。实习的焦虑5月，楼主...

SJTU_ZHY：我之前今年2月确诊的，就是焦虑症外加抑郁症，我经过整整三个月才慢慢走出来，我这都已经算算非常幸运的了。经过这一个经历，现在除非是那种真的能要我命的事情我才表现的很焦急，其他的都干**去吧，老子活了二十多年不是为了生下来遭罪的。 ***ing 求职和论文

投递比亚迪等公司10个岗位 > 秋招被确诊为…… 牛客创作赏金赛

点赞评论收藏

10-10 21:40

门头沟学院前端工程师

你们出生产事故了？

哪个程序员要背绩效了？

Java抽象带篮子：难蚌，点进图片上面就是我的大头😆

点赞评论收藏

10-16 12:29

携程_移动安全研发

转正了呀

Yushuu：你的确很厉害，但是有一个小问题：谁问你了？我的意思是，谁在意？我告诉你，根本没人问你，在我们之中0人问了你，我把所有问你的人都请来 party 了，到场人数是0个人，誰问你了？WHO ASKED？谁问汝矣？誰があなたに聞きましたか？누가 물어봤어？我爬上了珠穆朗玛峰也没找到谁问你了，我刚刚潜入了世界上最大的射电望远镜也没开到那个问你的人的盒，在找到谁问你之前我连癌症的解药都发明了出来，我开了最大距离渲染也没找到谁问你了我活在这个被辐射蹂躏了多年的破碎世界的坟墓里目睹全球核战争把人类文明毁灭也没见到谁问你了😆

点赞评论收藏