同事月薪 1.3w，自从被降薪后天天摸鱼，今天被叫去开会，以为要被裁，结果老板说:公司缺个技术总监，你去试试?月薪给你翻三倍

刚看到个贴子，说有个同事被降薪后开始天天摸鱼，结果反而被提拔成了技术总监，工资直接翻三倍。网友都炸了，有的说“命好”，有的说“老板脑子进水”。

有时候被降薪反而让人放下执念，不再讨好、不再内耗，反倒显出真本事。老板看得不是谁最辛苦，而是谁最能解决问题、最有潜力承担责任。

职场升迁，从来不是奖勤罚懒这么简单。被动努力、盲目拼命，不一定比懂得取舍的人更有价值。就像那句话说的：公司不缺螺丝钉，缺能带人往前走的那颗螺母。

这事提醒我们——别把降薪看成终点，也别把摸鱼当成堕落。真正有实力的人，哪怕沉寂一阵，也会被机会重新点亮。

算法题：01 矩阵

先把题目说清楚：给你一个只包含 0/1 的矩阵 mat，要返回同尺寸矩阵，里头每个位置存它到最近的 0 的“曼哈顿距离”（只能上下左右走一步算 1）。听起来像是最短路，但别上来就暴力从每个 1 往外扩，那是 O((mn)^2) 的灾难。

思路一：多源 BFS（更直觉的那种）

有个小技巧：所有 0 都是起点。把它们一次性丢进队列，距离置 0；把所有 1 的距离先标成无穷大。然后就像海水同时从很多海口涌进来，层层推进，谁先到就用谁的层数更新，保证是最近的。

• 初始化：把所有 0 入队，dist[r][c]=0；其余设成 INF。
• BFS：每出队一个格子，就看四邻，如果能把邻居的 dist 变小（dist[cur]+1），就更新并入队。
• 复杂度：每个格子最多入队一次，O(mn)，空间也 O(mn)。

import java.util.*;

publicclassSolutionBFS{
staticfinalint INF = 1_000_000;
staticfinalint[][] DIRS = {{1,0},{-1,0},{0,1},{0,-1}};

publicint[][] updateMatrix(int[][] mat) {
int m = mat.length, n = mat[0].length;
int[][] dist = newint[m][n];
        Deque<int[]> q = new ArrayDeque<>();

for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (mat[i][j] == 0) {
                    dist[i][j] = 0;
                    q.offer(newint[]{i, j});
                } else {
                    dist[i][j] = INF;
                }
            }
        }

while (!q.isEmpty()) {
int[] cur = q.poll();
int r = cur[0], c = cur[1];
for (int[] d : DIRS) {
int nr = r + d[0], nc = c + d[1];
if (nr < 0 || nr >= m || nc < 0 || nc >= n) continue;
if (dist[nr][nc] > dist[r][c] + 1) {
                    dist[nr][nc] = dist[r][c] + 1;
                    q.offer(newint[]{nr, nc});
                }
            }
        }
return dist;
    }
}

思路二：二维 DP 双向扫（更“轻量”的写法）

另一招更“文静”：先默认所有 1 的距离很大，然后扫两遍：

• 左上 → 右下：只用上、左更新当前格。
• 右下 → 左上：再用下、右补一次。 因为曼哈顿距离只跟四邻有关，两遍就把从四个方向来的信息都融合了。

publicclassSolutionDP{
staticfinalint INF = 1_000_000;

publicint[][] updateMatrix(int[][] mat) {
int m = mat.length, n = mat[0].length;
int[][] dist = newint[m][n];

// 初值
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
                dist[i][j] = (mat[i][j] == 0) ? 0 : INF;
            }
        }

// 第一次：左上 -> 右下
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (dist[i][j] == 0) continue;
if (i > 0) dist[i][j] = Math.min(dist[i][j], dist[i-1][j] + 1);
if (j > 0) dist[i][j] = Math.min(dist[i][j], dist[i][j-1] + 1);
            }
        }

// 第二次：右下 -> 左上
for (int i = m - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
if (i + 1 < m) dist[i][j] = Math.min(dist[i][j], dist[i+1][j] + 1);
if (j + 1 < n) dist[i][j] = Math.min(dist[i][j], dist[i][j+1] + 1);
            }
        }
return dist;
    }
}

该选哪一个？

• BFS 更像“最短路一体化”，好理解，适合会队列那一套的同学。
• DP 两遍写起来更紧凑，不用队列，也是一眼 O(mn)。

小坑提醒

边界判断别越界；INF 要够大但别溢出（1e6 就行）；矩阵全是 1 的情况题面一般不会给，但即便给了两个方案也能稳住。好了，到这儿基本就能在面试里又快又稳地过这题了。