贪心算法解决身高队列重建问题

1. 问题背景与理解

这道算法题描述的是：假设有打乱顺序的一群人站成一个队列，每个人由一个整数对(h,k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。我们需要根据这些信息重建这个队列。

举个实际例子，假设输入是[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]，那么正确的输出应该是[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]。这个结果满足每个人的k值要求：比如[5,2]前面有两个身高≥5的人（[5,0]和[7,0]），[4,4]前面有四个身高≥4的人。

这个问题在现实中有很多应用场景，比如：

• 活动入场时按特定规则排列参与者
• 数据库查询结果的特定排序需求
• 游戏中的角色排列系统

2. 解题思路分析

2.1 初步思考方向

看到这个问题，我首先想到的是如何确定每个人的位置。最直观的暴力解法是尝试所有排列组合，然后检查每个排列是否满足条件。但这样时间复杂度是O(n!)，显然不可行。

然后我思考能否先排序再调整。一个关键观察是：身高较高的人的位置相对容易确定，因为他们的k值只受更高的人影响。这提示我们可以先处理高个子。

2.2 关键突破点

经过几次尝试后，我发现以下规律：

1. 先按身高降序排列，身高相同的按k值升序排列
2. 然后按顺序将每个人插入到结果列表的k位置

为什么这样可行？因为：

• 高个子先排好后，后面插入的矮个子不会影响已经排好的高个子的k值
• 当身高相同时，k值小的应该排在前面（因为k表示前面有多少更高或相等的人）

2.3 算法选择

基于以上分析，我们可以：

1. 排序：O(nlogn)
2. 插入：每次插入是O(n)，总共O(n²)
   所以总时间复杂度是O(n²)，空间复杂度O(n)

这比暴力解法高效多了。Python中可以使用list的insert操作，虽然每次insert是O(n)，但实际应用中还是可以接受的。

3. 详细实现步骤

3.1 排序阶段

首先我们需要对原始数组进行排序。排序规则是：

• 主要按h降序
• h相同时按k升序

Python代码实现：

python复制people.sort(key=lambda x: (-x[0], x[1]))

例如输入[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]排序后变为：
[[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]

3.2 插入阶段

然后我们初始化一个空列表，按顺序将每个人插入到其k索引的位置：

python复制result = []
for p in people:
    result.insert(p[1], p)

让我们一步步看这个过程：

1. 插入[7,0] → [[7,0]]
2. 插入[7,1] → [[7,0],[7,1]]
3. 插入[6,1] → [[7,0],[6,1],[7,1]]
4. 插入[5,0] → [[5,0],[7,0],[6,1],[7,1]]
5. 插入[5,2] → [[5,0],[7,0],[5,2],[6,1],[7,1]]
6. 插入[4,4] → [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

3.3 完整代码实现

python复制def reconstructQueue(people):
    # 先按h降序，k升序排序
    people.sort(key=lambda x: (-x[0], x[1]))
    result = []
    for p in people:
        result.insert(p[1], p)
    return result

4. 算法正确性证明

为什么这个算法是正确的？我们可以从几个方面来理解：

1. 高个子优先：高个子插入时，队列中还没有更矮的人，所以他们的k值只受已经插入的更高的人影响。而更高的人已经按k值排好，所以直接插入到k位置就能满足条件。

2. 矮个子后处理：当插入矮个子时，所有比他高的人已经排好，他只需要插入到满足前面有k个更高的人的位置即可。由于高个子已经固定，插入位置是唯一确定的。

3. 相同身高处理：对于身高相同的人，按k升序排列。这样先处理k值小的，可以确保后面相同身高的人插入时不会影响前面已经满足的条件。

5. 复杂度分析与优化

5.1 时间复杂度

• 排序：O(nlogn)
• 插入：最坏情况下每次insert是O(n)，总共O(n²)
  所以总时间复杂度是O(n²)

5.2 空间复杂度

需要额外的O(n)空间存储结果，不考虑输入输出的话是O(n)

5.3 可能的优化

如果使用链表结构，插入操作可以是O(1)，但查找插入位置仍然是O(n)，所以整体还是O(n²)。在Python中，list的insert操作在中间位置插入需要移动元素，所以实际性能可能不如理论分析。

对于大规模数据，可以考虑更高效的数据结构，但在算法题中这个实现已经足够。

6. 边界情况与测试用例

6.1 边界情况考虑

1. 空输入：应该返回空列表
2. 所有人都一样高：k值应该等于其原始索引
3. 所有人的k值都是0：应该按身高降序排列
4. 所有人的k值都是n-1：应该按身高升序排列

6.2 测试用例示例

python复制test_cases = [
    ([], []),
    ([[7,0]], [[7,0]]),
    ([[7,0],[7,1]], [[7,0],[7,1]]),
    ([[6,0],[5,0]], [[5,0],[6,0]]),
    ([[5,0],[6,0]], [[5,0],[6,0]]),
    ([[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]], 
     [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]])
]

7. 实际应用与变种

7.1 实际应用场景

1. 活动排队系统：需要让某些人前面有特定数量的更高的人
2. 数据库查询：需要按多个字段特定规则排序
3. 游戏开发：角色按特定规则排列显示

7.2 问题变种

1. 按后面的人数排序：如果k表示后面更高的人的数量，如何解决？
2. 二维扩展：如果考虑体重等其他因素，如何重建队列？
3. 动态更新：当有新的人加入队列时，如何高效调整？

8. 常见错误与调试技巧

8.1 常见错误

1. 排序规则错误：忘记处理身高相同的情况，导致k值计算错误
2. 插入顺序错误：先处理矮个子会导致后续插入高个子时k值不准确
3. 边界条件遗漏：没有处理空输入或单元素情况

8.2 调试技巧

1. 打印中间结果：在排序后和每次插入后打印当前队列
2. 小规模测试：先用小例子手动计算预期结果
3. 边界测试：专门测试空输入、单元素、全相同身高等情况

9. 算法比较与选择

9.1 与其他方法对比

1. 暴力法：尝试所有排列，时间复杂度O(n!)，不可行
2. 贪心算法：本文的方法就是一种贪心策略，每次做出局部最优选择
3. 分治法：不太适合这个问题，因为子问题之间相互影响

9.2 为什么贪心算法适用

这个问题具有贪心选择性质：局部最优解能导致全局最优解。通过每次处理当前最高的人，并放在正确位置，可以确保后续操作不会破坏已经满足的条件。

10. 扩展思考

10.1 如果k值可能有误

如果输入的k值可能有误（比如不可能满足），如何检测？可以在重建后验证每个人的k值是否匹配。

10.2 多维度排序

如果除了身高还有其他排序维度（如体重、年龄），如何扩展这个算法？可能需要定义更复杂的排序规则。

10.3 性能优化

对于非常大的n（如百万级），如何优化？可能需要更高效的数据结构或并行处理，但基本思路不变。

这个问题的核心在于发现"高个子先排"这一关键观察点。在实际编程面试中，面试官通常会期待你能够通过举例和逐步分析得出这个结论，而不是直接给出答案。建议多练习类似的排序+插入问题，培养解题直觉。