互联网裁员，先裁掉效率低的，还是潜力小的?

这道“隔离病毒”的算法题，第一眼看上去有点像在玩 《瘟疫公司》：地图上有病毒蔓延，我们得修墙把它围起来，不让它继续传染。听起来挺轻松的对吧？但真做起来，属实是个活脱脱的模拟类地狱级别题目。

题目大概意思就是：二维网格上，1代表病毒感染区，0代表健康区。每天病毒会往上下左右的健康区扩散。我们每天只能修一道“墙”，把某一块感染区域围起来，防止它扩散。我们要做的就是模拟这个过程，并统计我们一共修了多少段墙。

说实话，我第一反应是：这咋有点像领导让我选一个模块加班重构，还只能选一个，其他模块就烂在那里继续“扩散”Bug。每天都像火在烧，我还得评估“哪块最危险”。太真实了！

但回到正题，模拟题也不是说光靠暴力就完事了，这题的关键是：

1. 1. 找出所有感染区域。
2. 2. 分析每个区域可能感染的健康区数量。
3. 3. 每天选那个感染最多健康区的区域去围墙。
4. 4. 其他区域继续扩散。
5. 5. 不断重复直到病毒不能再扩散。

所以你看，还是有点策略性的。

贴点核心代码看看怎么搞：

classSolution {
int[][] dirs = {{0,1}, {1,0}, {0,-1}, {-1,0}};
int m, n;

publicintcontainVirus(int[][] isInfected) {
        m = isInfected.length;
        n = isInfected[0].length;
inttotalWalls=0;

while (true) {
            List<Set<Integer>> regions = newArrayList<>();
            List<Set<Integer>> frontiers = newArrayList<>();
            List<Integer> walls = newArrayList<>();
boolean[][] visited = newboolean[m][n];

for (inti=0; i < m; i++) {
for (intj=0; j < n; j++) {
if (isInfected[i][j] == 1 && !visited[i][j]) {
                        Set<Integer> region = newHashSet<>();
                        Set<Integer> frontier = newHashSet<>();
int[] wall = newint[1];
                        dfs(i, j, isInfected, visited, region, frontier, wall);
                        regions.add(region);
                        frontiers.add(frontier);
                        walls.add(wall[0]);
                    }
                }
            }

if (regions.isEmpty()) break;

intmaxIdx=0;
for (inti=1; i < frontiers.size(); i++) {
if (frontiers.get(i).size() > frontiers.get(maxIdx).size()) {
                    maxIdx = i;
                }
            }

            totalWalls += walls.get(maxIdx);

for (inti=0; i < regions.size(); i++) {
for (int code : regions.get(i)) {
intx= code / n, y = code % n;
if (i == maxIdx) {
                        isInfected[x][y] = -1;  // 被围住
                    } else {
for (int[] d : dirs) {
intnx= x + d[0], ny = y + d[1];
if (inArea(nx, ny) && isInfected[nx][ny] == 0) {
                                isInfected[nx][ny] = 1;
                            }
                        }
                    }
                }
            }
        }
return totalWalls;
    }

voiddfs(int x, int y, int[][] grid, boolean[][] visited,
             Set<Integer> region, Set<Integer> frontier, int[] wall) {
        visited[x][y] = true;
        region.add(x * n + y);
for (int[] d : dirs) {
intnx= x + d[0], ny = y + d[1];
if (inArea(nx, ny)) {
if (grid[nx][ny] == 0) {
                    wall[0]++;
                    frontier.add(nx * n + ny);
                } elseif (grid[nx][ny] == 1 && !visited[nx][ny]) {
                    dfs(nx, ny, grid, visited, region, frontier, wall);
                }
            }
        }
    }

booleaninArea(int x, int y) {
return x >= 0 && y >= 0 && x < m && y < n;
    }
}

整个过程就像带领开发团队“封堵漏洞”，得不断评估哪个模块最容易“炸”，哪个需要立刻修复，剩下的就先放放。每一轮你只能灭一个火堆，其他的火你还得眼睁睁看着烧起来……

这种题其实我觉得有个挺有意思的点，它教的不是算法，而是决策与取舍，和我们做项目决策其实一样。我们永远做不到“今天修完所有bug”，但能通过判断“最有可能出事故的bug”优先干掉，来最大化系统稳定性。

你看，连病毒都得靠优先级去围，程序员干活凭什么不排优先级？！

顺带一提，这题模拟+DFS组合拳打得漂亮，能打爆不少暴力选手的脑瓜子。如果数据量再大点，我甚至都想上个BFS+Union-Find+优先队列一波Combo🥷，不过目前这个范围内，DFS足够用。

最后就想说一句：别小看模拟题，写得明白了，它甚至能帮你理解现实的“火烧连营”项目管理现场。看完这题，我甚至都有点想重构我们那个快递模块了，感觉里面藏了不少“病毒区域”。

有没有人也写过类似的题，感觉哪题更像现实中项目火灾现场的？欢迎一起来吐槽。