投雪花之前到处搜 Snowflake HackerRank questions 的资料，看到有人说他家 OA 是北美 tech 圈最有辨识度的 OA 之一，做完之后觉得这话没毛病。两道题，没有一道是模板题，但你要是提前见过原题，20 分钟就能走人。我运气不错，撞上的两道都是地里和小红书上被讨论烂了的经典 Snowflake HackerRank questions ，做的时候基本是默写。
趁记忆还热乎，把题目和思路都写下来，投 Snowflake 的朋友可以直接对着准备。
Snowflake OA 基本信息
平台是 HackerRank，两道题，难度都在 Medium-Hard 这个档。别看只有两道，数据规模全是 2×10⁵ 起步，暴力解直接见祖宗，必须把复杂度想明白了再动手。雪花的题库更新不算勤，经典题反复出，所以刷原题的性价比是真的高。
第一题：Minimum Height
题目
给你一棵有根树，代表一个数据库的表结构，表 1 是根。你有 max_operations 次操作机会，每次可以选一个节点，把它跟父节点之间的边剪断，然后连同整棵子树直接挂到根下面——相当于把一坨很深的节点整体提上来。
问：操作完之后，树的高度最小能压到多少。
举个例子，四个节点连成一条链 1-3-2-4，高度是 3。给你一次操作机会，把 4 剪下来挂到根下面，高度就变成 2 了。
解题思路
看到”最小化最大值”这种问法，条件反射就应该是二分答案。这个信号词太经典了，树的高度、答案单调，齐活。
框架就是：二分一个高度 H，然后写个 check 函数判断”最多用 max_operations 次操作，能不能把树压到 H 以内”。
check 怎么写？自底向上贪心。每个节点维护一个”往下延伸的最大距离”，从叶子往上算，一旦发现某个节点再往上走就要超 H 了，就在这儿剪断，整棵子树扔给根，操作数加一。剪的位置越深越划算，因为一刀下去受益的节点越多。最后看操作数有没有超预算。
有个坑要注意：子树挂到根下面之后它自己还有高度，所以被剪下来的子树自身深度不能超过 H-1，check 里这个条件漏了会 WA。
代码
import sys
from collections import defaultdict
def getMinimumHeight(tree_nodes, tree_from, tree_to, max_operations):
graph = defaultdict(list)
for u, v in zip(tree_from, tree_to):
graph[u].append(v)
graph[v].append(u)
def check(H):
if H <= 0:
return False
ops = 0
depth_down = [0] * (tree_nodes + 1)
parent = [0] * (tree_nodes + 1)
order = []
visited = [False] * (tree_nodes + 1)
stack = [1]
visited[1] = True
while stack:
node = stack.pop()
order.append(node)
for nxt in graph[node]:
if not visited[nxt]:
visited[nxt] = True
parent[nxt] = node
stack.append(nxt)
depth_from_root = [0] * (tree_nodes + 1)
for node in order:
if node != 1:
depth_from_root[node] = depth_from_root[parent[node]] + 1
for node in reversed(order):
if node == 1:
continue
if depth_down[node] + depth_from_root[node] > H:
if depth_down[node] > H - 1:
return False
ops += 1
if ops > max_operations:
return False
else:
p = parent[node]
depth_down[p] = max(depth_down[p], depth_down[node] + 1)
return ops <= max_operations
lo, hi = 1, tree_nodes - 1
while lo < hi:
mid = (lo + hi) // 2
if check(mid):
hi = mid
else:
lo = mid + 1
return lo一个工程细节：n 到 2×10⁵，Python 递归写 DFS 会爆栈，老老实实用迭代版，别偷懒。
整体复杂度 O(n log n)，稳过。
第二题：Horizontal Pod Autoscaler
题目
场景包装是 k8s 的 Pod 自动扩缩容，其实就是个数组操作题。n 个微服务各有一个 Pod 数量，然后给你一堆日志，两种操作：
[1, p, x]：把第 p 个服务的 Pod 数直接改成 x。
[2, -1, x]：所有当前 Pod 数小于 x 的服务，统一提到 x——相当于设了个全局下限。
跑完所有日志，问每个服务最后是多少。
解题思路
最直觉的做法是老实模拟，type 2 来一条就全体扫一遍。但 n 和 m 都是 2×10⁵，最坏 O(n×m) 就是 4×10¹⁰，想都不用想，超时超到天上去。
破局点是换个角度想：别管过程，直接想每个服务的最终值到底由什么决定。
答案其实就两个东西：它最后一次被单独改成的值，以及这次修改之后出现过的最大全局下限。俩取个 max，完事。为什么？因为最后一次单独修改会把之前的一切覆盖掉，而之后的全局下限里只有最大的那个有意义。
想通这一层，实现就三步：
一、正着扫一遍日志，记每个服务最后一次被 type 1 改的时间和值。没被改过的，就当它在时间 0 被”改”成了初始值。
二、对 type 2 操作建个后缀最大值数组，suffix_max[t] 表示时间 t 往后最大的全局下限。
三、每个服务答案 = max(最后单改的值, 那之后的后缀最大下限)。
代码
def findPodCount(pods, logs):
n = len(pods)
m = len(logs)
last_time = [0] * n
last_value = pods[:]
for t, log in enumerate(logs, 1):
if log[0] == 1:
p, x = log[1] - 1, log[2]
last_time[p] = t
last_value[p] = x
suffix_max = [0] * (m + 2)
for t in range(m, 0, -1):
suffix_max[t] = suffix_max[t + 1]
if logs[t - 1][0] == 2:
suffix_max[t] = max(suffix_max[t], logs[t - 1][2])
return [max(last_value[i], suffix_max[last_time[i] + 1]) for i in range(n)]O(n + m)，一遍过。这题想通了代码就十几行，想不通就只能对着超时的暴力解干瞪眼，属于典型的”思维题”。
写在最后
这两道题给我的感受是：雪花不考你会不会写代码，考你能不能在读完题的三分钟内定位到正确的算法框架。
好消息是雪花题库复现率高，这两道都是被写烂的经典题，考前把地里近半年的雪花帖过一遍，大概率能撞上原题。我备考的时候还参考了 InterviewShow 整理的北美大厂 OA 题库,雪花这两道都在里面,带思路提示,比自己硬啃效率高不少,他们也还提供OA辅助，面试辅助，挺稳的，有需要可以去看看。祝大家都能像我一样开题即默写,20 分钟潇洒走人。