研发工作快四年了，工资还没破两万，是我太菜了吗，想到假如在 35岁我还是这个工资，然后要毕业就头疼

刚看到个贴子：一位做研发的网友，工作快四年了，月薪还没破两万，怀疑自己是不是太菜，想到如果35岁还是这点工资，就对未来很焦虑。

网友回复我看了看，有的说是大环境不好，有的直接劝他转行，还有人酸一句“说明你确实不行”。我觉得吧，这些话都不重要。怎么说呢，工资只是阶段性结果，不能拿一家公司、几年时间给自己下终身判决。

从我的角度看，关键就两点：一是好好盘盘这四年到底沉淀了什么，项目经验、核心能力、人脉有没有涨级；二是敢不敢做选择，是继续在技术上卷深，还是去更看重产出的平台。

35岁不是突然到的，它是接下来十年每一个小决定叠出来的。与其天天算“35岁多少薪”，不如今天先让自己比昨天值钱一点点。路还长，别被一串数字吓住了。

昨天晚上十一点多吧，我在公司楼下抽烟（别学啊…咳），我们组小李突然问我：哥，这个“水位上升的泳池中游泳”到底想考啥？我当时脑子还卡在白天线上排查那种“怎么又超时了”的烦躁里，跟之前那次看 trace id 一路追到 Feign 超时差不多的感觉，就是你以为是业务，结果是“路径代价”的定义没想对。

这个题吧，别被“游泳”“水位上升”带跑偏了。你站在 (0,0) 想到 (n-1,n-1)，水位 t 从小往上涨，只有格子高度 <= t 才能进。等价翻译一下：你走一条路，这条路上所有格子的最大高度是多少？你想让这个“最大值”尽量小。嗯，就是那个……怎么说呢，路径的代价不是加法，是 max。像我之前抓 TCP 包那个 1024 卡 bug 一样，本质是“边界条件怎么定义”，定义错了你再怎么跑都不对劲。

所以做法就很“架构味儿”：用最短路思想，但是把距离从“累加”改成“取最大”。从起点开始，当前到达某格子的最小代价 = 这一路上最大高度的最小可能。每次从优先队列里拿代价最小的格子扩展，邻居的新代价就是 max(当前代价, 邻居高度)，谁小更新谁。你一听就知道，这是 Dijkstra 的壳子换了个运算。对了，有人会用并查集按高度从低到高“灌水”连通起终点也行，但我写 Java 更顺手还是 PQ。顺便一嘴，选型这事儿也一样，别迷信名字，得看机制合不合适。

代码我给你写一份，能直接跑，没整花里胡哨的：

import java.util.*;

/**
 * 题意：找到一条从 (0,0) 到 (n-1,n-1) 的路径，
 * 使得路径上格子高度的最大值最小。
 * 做法：Dijkstra，把“距离”定义成路径最大高度。
 */
classSolution{
privatestaticfinalint[] DX = {1, -1, 0, 0};
privatestaticfinalint[] DY = {0, 0, 1, -1};

staticclassNode{
int x, y, cost; // cost = 到这里为止路径上的最大高度
        Node(int x, int y, int cost) { this.x = x; this.y = y; this.cost = cost; }
    }

publicintswimInWater(int[][] grid){
int n = grid.length;
int[][] best = newint[n][n];
for (int[] row : best) Arrays.fill(row, Integer.MAX_VALUE);

        PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a.cost));
        best[0][0] = grid[0][0];
        pq.offer(new Node(0, 0, best[0][0]));

boolean[][] done = newboolean[n][n];

while (!pq.isEmpty()) {
            Node cur = pq.poll();
if (done[cur.x][cur.y]) continue;
            done[cur.x][cur.y] = true;

if (cur.x == n - 1 && cur.y == n - 1) return cur.cost;

for (int k = 0; k < 4; k++) {
int nx = cur.x + DX[k], ny = cur.y + DY[k];
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
if (done[nx][ny]) continue;

int nextCost = Math.max(cur.cost, grid[nx][ny]);
if (nextCost < best[nx][ny]) {
                    best[nx][ny] = nextCost;
                    pq.offer(new Node(nx, ny, nextCost));
                }
            }
        }
return -1; // 理论上不会到这里
    }
}

你看这题最“阴”的点就是：很多人下意识 BFS，结果发现水位不是一步步的层次；或者做 DP 发现依赖乱套。其实你把“代价”想成 max，就一下顺了。行了我先不说了，楼下风太大，烟都快被吹没了，等会儿还得回去改个日志字段名，烦。