力扣刷题之699.掉落的方块

题干描述

在二维平面上的 x 轴上，放置着一些方块。

给你一个二维整数数组 positions ，其中 positions[i] = [lefti, sideLengthi] 表示：第 i 个方块边长为 sideLengthi ，其左侧边与 x 轴上坐标点 lefti 对齐。

每个方块都从一个比目前所有的落地方块更高的高度掉落而下。方块沿 y 轴负方向下落，直到着陆到 另一个正方形的顶边 或者是 x 轴上 。一个方块仅仅是擦过另一个方块的左侧边或右侧边不算着陆。一旦着陆，它就会固定在原地，无法移动。

在每个方块掉落后，你必须记录目前所有已经落稳的 方块堆叠的最高高度 。

返回一个整数数组 ans ，其中 ans[i] 表示在第 i 块方块掉落后堆叠的最高高度。

示例 1：

输入：positions = [[1,2],[2,3],[6,1]]
输出：[2,5,5]
解释：
第 1 个方块掉落后，最高的堆叠由方块 1 组成，堆叠的最高高度为 2 。
第 2 个方块掉落后，最高的堆叠由方块 1 和 2 组成，堆叠的最高高度为 5 。
第 3 个方块掉落后，最高的堆叠仍然由方块 1 和 2 组成，堆叠的最高高度为 5 。
因此，返回 [2, 5, 5] 作为答案。

示例 2：

输入：positions = [[100,100],[200,100]]
输出：[100,100]
解释：
第 1 个方块掉落后，最高的堆叠由方块 1 组成，堆叠的最高高度为 100 。
第 2 个方块掉落后，最高的堆叠可以由方块 1 组成也可以由方块 2 组成，堆叠的最高高度为 100 。
因此，返回 [100, 100] 作为答案。
注意，方块 2 擦过方块 1 的右侧边，但不会算作在方块 1 上着陆。

题干解析

问题描述

• 在二维平面上面的X轴上放置了一些方块。每个方块从一个比目前所有的落地方块更高的高度掉落下来，沿着Y轴负方向下落，直到着陆到另一个方块的顶边或者X轴上。
• 每个方块只能固定在另一个方块的顶边或X轴上。如果仅仅是擦过另一个方块的左侧边或右侧边，不算作着陆。
• 我们需要记录每个方块掉落后，堆叠的最高高度。

解题思路 

       为了计算每个方块掉落后的最高高度，我们需要模拟每个方块的掉落过程，并在每次掉落后更新当前的堆叠高度。具体步骤如下：

1.初始化高度数组：

• 使用一个高度数组heights来记录每个方块掉落后的高度。

2.模拟每个方块的掉落过程：

• 对于每个方块，计算它的左边界left1和右边界right1。
• 初始设置当前方块的高度为其边长sideLengthi。
• 遍历之前所有已经掉落的方块，检查当前方块是否与之前的方块重叠。如果重叠，更新当前方块的高度，使其叠加在之前的方块上。

3.更新最高高度：

• 在每个方块掉落后，更新高度数组，使得每个位置的高度为当前最高的堆叠高度。

4.返回结果：

• 返回高度数组heights，其中记录了每个方块掉落后的最高高度。

完整代码如下 

#include <stdio.h>
#include <stdlib.h>

// 宏定义：计算两个数中的较大值
#define MAX(a, b) ((a) > (b) ? (a) : (b))

/**
 * fallingSquares函数：计算每个方块掉落后的最高高度
 * @param positions: 二维整数数组，表示方块的位置和边长
 * @param positionsSize: 数组positions的大小
 * @param positionsColSize: 数组positions每一行的大小
 * @param returnSize: 返回数组的大小
 * @return: 返回每个方块掉落后的最高高度数组
 */
int* fallingSquares(int** positions, int positionsSize, int* positionsColSize, int* returnSize) {
    // 动态分配数组，用于存储每个方块掉落后的高度
    int *heights = (int *)malloc(sizeof(int) * positionsSize);
    
    // 遍历每个方块，计算其掉落后的高度
    for (int i = 0; i < positionsSize; i++) {
        int left1 = positions[i][0]; // 当前方块的左边界
        int right1 = positions[i][0] + positions[i][1] - 1; // 当前方块的右边界
        heights[i] = positions[i][1]; // 当前方块的初始高度为其边长
        
        // 遍历之前已经掉落的方块，计算当前方块的高度
        for (int j = 0; j < i; j++) {
            int left2 = positions[j][0]; // 之前方块的左边界
            int right2 = positions[j][0] + positions[j][1] - 1; // 之前方块的右边界
            
            // 检查当前方块是否与之前的方块重叠
            if (right1 >= left2 && right2 >= left1) {
                // 更新当前方块的高度，使其叠加在之前的方块上
                heights[i] = MAX(heights[i], heights[j] + positions[i][1]);
            }
        }
    }
    
    // 更新高度数组，使其每个位置的高度为当前最高的堆叠高度
    for (int i = 1; i < positionsSize; i++) {
        heights[i] = MAX(heights[i], heights[i - 1]);
    }
    
    // 设置返回数组的大小
    *returnSize = positionsSize;
    return heights;
}

int main() {
    // 示例 1
    // 初始化测试用例的方块位置
    int positionsSize = 3;
    int positionsColSize[] = {2, 2, 2};
    int* positions[] = {
        (int[]){1, 2},
        (int[]){2, 3},
        (int[]){6, 1}
    };

    // 调用fallingSquares函数，并获取结果
    int returnSize;
    int* result = fallingSquares(positions, positionsSize, positionsColSize, &returnSize);

    // 输出结果数组
    printf("示例 1 结果: ");
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    // 示例 2
    // 初始化测试用例的方块位置
    int positions2Size = 2;
    int positions2ColSize[] = {2, 2};
    int* positions2[] = {
        (int[]){100, 100},
        (int[]){200, 100}
    };

    // 调用fallingSquares函数，并获取结果
    int return2Size;
    int* result2 = fallingSquares(positions2, positions2Size, positions2ColSize, &return2Size);

    // 输出结果数组
    printf("示例 2 结果: ");
    for (int i = 0; i < return2Size; i++) {
        printf("%d ", result2[i]);
    }
    printf("\n");

    // 释放动态分配的内存
    free(result);
    free(result2);

    return 0;
}