HR的无奈：千挑万选的员工为何入职不到一周就辞职？

刷到一位HR网友吐槽：最无奈的瞬间，就是人好不容易过了几轮面试，资料背调、薪资沟通、入职流程一套走完，坐下还没把工位捂热呢，转头来一句“我想离职”。

我觉得这比线上事故还扎心。你以为自己把候选人“筛”成了最优解，结果对方用一周时间告诉你：不合适。HR那边投入的时间、沟通成本直接清零，岗位得重新挂，业务方还会阴阳一句“你们到底怎么选的”。

更尴尬的是，新人离开时通常也不吵不闹，理由还挺体面：方向不符、节奏不适应、家里有事——听着像日志里那句“unknown error”，你还真不好定位问题。

我觉得真要怪，也不全怪HR，有些岗位“上岗即变形”，面试讲A，入职变B，换谁都想跑路。

HR夹在中间，像夹心饼干，甜不甜不知道，反正挺碎的。

算法题：以图判树

哎这个“以图判树”吧，我跟你说我真是在项目里被它坑过的……那会儿做个设备拓扑校验（就类似你扫出来一堆节点连线），同事一脸淡定说“这不就是判断是不是树吗”，我当时还嘴硬：树嘛，连通、没环就完了……结果线上一堆脏数据，孤岛、重复边、自环全来了，日志刷得跟下雨一样，才老实把判定写严一点。

你要的算法题思路其实就两句话： 1） 边数必须是 n-1 （树的基本硬指标） 2） 图必须连通且无环 （满足这俩就稳）

实现上我一般用并查集（Union-Find），因为写起来快，而且一旦发现成环可以立刻返回 false，省事。流程就像：先看 m 是不是等于 n-1，不是直接 false；然后遍历每条边 u-v：

• u==v 这种自环，直接 false（有些题不出现，但我习惯防一手）

• 如果 find(u)==find(v)，说明要把两个已经连通的点再连一次 -> 成环 -> false

• 否则 union(u,v) 最后再检查是不是全连通：用一个根作为基准，看所有点 find(i) 是否一致。

下面这段 java 代码我给你写成能直接用的那种（输入是 n 和 edges 数组），你平时刷题丢进去就行：

import java.util.*;

 publicclassSolution{
publicbooleanvalidTree(int n, int[][] edges){
// 一上来先卡死边数，不等于 n-1 肯定不是树
if (n <= 0) returnfalse;
if (edges == ) return n == 1;
if (edges.length != n - 1) returnfalse;

 UnionFind uf = new UnionFind(n);

 for (int[] e : edges) {
int u = e[0], v = e[1];

 // 防一手自环
if (u == v) returnfalse;

 // 防越界（有些平台不会给，但真实数据里我见过）
if (u < 0 || u >= n || v < 0 || v >= n) returnfalse;

 // 成环检测：同一个集合里还要连
if (uf.find(u) == uf.find(v)) returnfalse;

 uf.union(u, v);
}

 // 因为 edges.length == n-1 且无环，其实已经能推出连通
// 但我还是喜欢再验一遍，写严一点不吃亏
int root = uf.find(0);
for (int i = 1; i < n; i++) {
if (uf.find(i) != root) returnfalse;
}
returntrue;
}

 staticclassUnionFind{
int parent;
int rank; // 或 size 都行

 UnionFind(int n) {
parent = newint[n];
rank = newint[n];
for (int i = 0; i < n; i++) parent[i] = i;
}

 intfind(int x){
if (parent[x] != x) parent[x] = find(parent[x]); // 路径压缩
return parent[x];
}

 voidunion(int a, int b){
int ra = find(a), rb = find(b);
if (ra == rb) return;

 // 按秩合并
if (rank[ra] < rank[rb]) {
parent[ra] = rb;
} elseif (rank[ra] > rank[rb]) {
parent[rb] = ra;
} else {
parent[rb] = ra;
rank[ra]++;
}
}
}

 // 你想本地跑一下的话，加个 main 也行
publicstaticvoidmain(String[] args){
Solution s = new Solution;
System.out.println(s.validTree(5, newint[][]{{0,1},{0,2},{0,3},{1,4}})); // true
System.out.println(s.validTree(5, newint[][]{{0,1},{1,2},{2,3},{1,3},{1,4}})); // false 有环
System.out.println(s.validTree(4, newint[][]{{0,1},{2,3},{1,2}})); // true
}
}

对了我再插一句很“脏”的情况：有的题会给重复边，比如 (0,1) 来两次，这代码会在第二次 find 一样直接判成环返回 false——这其实符合“简单无向图的树”定义；如果你遇到那种“重复边不算”的奇葩口径，那就得先去重再判，但一般算法题不这么整人。

复杂度也挺舒服：并查集几乎是 O(m α(n))，你就当近似 O(m) 就行，刷题够用了。你要是想换 BFS/DFS 也行，但并查集写起来更像“线上能扛脏数据”的感觉，嗯……我反正就爱这么写。