迪子员工爆料：老员工的学历和能力都堪忧啊，三本野鸡大学毕业，还管理一堆985，211硕士，华为腾讯的下属，真不害臊！

今天这个话题真的让我忍不住掏出键盘来聊两句——迪子员工爆料，说他们的老员工学历和能力都堪忧，三本野鸡大学毕业，居然还管着一堆985、211硕士，甚至华为、腾讯出来的下属。这画面感真是让我忍不住扶额，忍不住又想笑😂。

先说句公道话，我觉得学历这个东西，在职场确实能加点buff，但也不能一棍子打死所有三本。

很多人吐槽的“学历鄙视链”，说白了，就是在起跑线上的差距。但进了公司，大家跑得快不快，可不是光看起跑线，还是得看脚力和脑子。

再一个，管理能力和学历之间，关系真的没那么铁。你是清华的博士，但你会不会调动团队？会不会hold住项目？老员工搞不好就是那种“读书不行，但社会这本书读通了”的狠人😂。

不过换个角度，爆料的人或许也不是单纯在吐槽学历，更多是在质疑这个老员工的领导能力。如果学历没优势，能力也看不出强在哪，那确实让下属心里有点疙瘩。

但问题是，有些领导未必是靠技术上位，而是公司资源、人脉、经验这种软实力占优。 别问，问就是职场生态位的问题 。 所以，别纠结学历高低了，在职场上，要想不被管，最好的办法就是：干到没人能管你！

算法题：离建筑物最近的距离

今天咱聊聊一个算法问题，叫“ 离建筑物最近的距离 ”。

题目：

给你一个二维网格，有些格子是建筑物（用1表示），有些是空地（用0表示），还有些是障碍物（用-1表示）。你的任务是找到一个空地，这块空地到所有建筑物的距离之和最小。啥？没听懂？简单点说，咱找块地，能让“送外卖”的代价最小。

这题咋整呢？暴力法可以试，但时间复杂度直接起飞。假如网格是1000x1000大小，暴力解法可能会让你电脑的风扇直接起飞，散热散成暖手宝。🤦‍♂️所以得来点高级的，比如 BFS（广度优先搜索） 。 BFS是什么？

如果你不熟悉，BFS就是那种一层一层探索的策略。比如下棋的时候，先走一步，然后再看下一步能怎么走。每次搜索当前的“圈”，再扩展到更远的圈。

代码时间：来点实战

咱可以用Java写个示例，这样说话更有说服力。核心思路就是：

1. 从每个建筑物出发，用BFS计算到所有空地的距离。
2. 累加所有建筑物对空地的距离，找到最小值。

import java.util.*;

public class Solution {
    public int shortestDistance(int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        int[][] totalDistance = new int[rows][cols];
        int[][] reachCount = new int[rows][cols];
        int buildingCount = 0;

        // 定义四个方向
        int[] directions = {-1, 0, 1, 0, -1};

        // 先统计建筑物的个数
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 1) {
                    buildingCount++;
                    bfs(grid, i, j, totalDistance, reachCount, directions);
                }
            }
        }

        // 找最小距离
        int minDistance = Integer.MAX_VALUE;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 0 && reachCount[i][j] == buildingCount) {
                    minDistance = Math.min(minDistance, totalDistance[i][j]);
                }
            }
        }

        return minDistance == Integer.MAX_VALUE ? -1 : minDistance;
    }

    private void bfs(int[][] grid, int startX, int startY, int[][] totalDistance, int[][] reachCount, int[] directions) {
        int rows = grid.length;
        int cols = grid[0].length;
        boolean[][] visited = new boolean[rows][cols];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{startX, startY});
        visited[startX][startY] = true;

        int distance = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            distance++;
            for (int i = 0; i < size; i++) {
                int[] current = queue.poll();
                for (int d = 0; d < 4; d++) {
                    int newX = current[0] + directions[d];
                    int newY = current[1] + directions[d + 1];
                    if (newX >= 0 && newX < rows && newY >= 0 && newY < cols 
                            && grid[newX][newY] == 0 && !visited[newX][newY]) {
                        visited[newX][newY] = true;
                        queue.offer(new int[]{newX, newY});
                        totalDistance[newX][newY] += distance;
                        reachCount[newX][newY]++;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] grid = {
                {1, 0, 2, 0, 1},
                {0, 0, 2, 0, 0},
                {0, 0, 0, 0, 0},
        };
        System.out.println(sol.shortestDistance(grid)); // Output: 7
    }
}

代码分析：

1. BFS的作用 ：每次从建筑物出发，找到所有能到的空地，累加距离。
2. 统计机制 ： reachCount 记录某个空地能被多少建筑物到达。如果一个空地不能被所有建筑物到达，那它不符合条件。
3. 复杂度优化 ：相比暴力法，这种思路省了很多重复计算。
   

你们怎么看？觉得这种题简单还是烧脑？评论区欢迎交流！
-END -
ok，今天先说到这，老规矩，给大家分享一份不错的副业资料，感兴趣的同学找我领取。

以上，就是今天的分享了， 看完文章记得右下角给何老师点赞，也欢迎在评论区写下你的留言 。