leetcode 699. Falling Squares

最新推荐文章于 2023-01-06 23:01:25 发布

原创最新推荐文章于 2023-01-06 23:01:25 发布 · 628 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

280 篇文章

订阅专栏

本文介绍了一种求解类似俄罗斯方块游戏中最大堆叠高度的算法。通过遍历每个下落的方块并计算其可能达到的最大高度，最终得到一系列高度记录。此算法适用于无限长数轴上的方块下落场景。

699. Falling Squares

On an infinite number line (x-axis), we drop given squares in the order they are given.

The i-th square dropped (positions[i] = (left, side_length)) is a square with the left-most point being positions[i][0]and sidelength positions[i][1].

The square is dropped with the bottom edge parallel to the number line, and from a higher height than all currently landed squares. We wait for each square to stick before dropping the next.

The squares are infinitely sticky on their bottom edge, and will remain fixed to any positive length surface they touch (either the number line or another square). Squares dropped adjacent to each other will not stick together prematurely.

Return a list ans of heights. Each height ans[i] represents the current highest height of any square we have dropped, after dropping squares represented by positions[0], positions[1], ..., positions[i].

Example 1:

Input: [[1, 2], [2, 3], [6, 1]]
Output: [2, 5, 5]
Explanation:

After the first drop of positions[0] = [1, 2]:_aa_aa-------The maximum height of any square is 2.

After the second drop of positions[1] = [2, 3]:__aaa__aaa__aaa_aa___aa__--------------The maximum height of any square is 5. The larger square stays on top of the smaller square despite where its centerof gravity is, because squares are infinitely sticky on their bottom edge.

After the third drop of positions[1] = [6, 1]:__aaa__aaa__aaa_aa_aa___a--------------The maximum height of any square is still 5.Thus, we return an answer of [2, 5, 5].

Example 2:

Input: [[100, 100], [200, 100]]
Output: [100, 100]
Explanation: Adjacent squares don't get stuck prematurely - only their bottom edge can stick to surfaces.

Note:

1 <= positions.length <= 1000.1 <= positions[i][0] <= 10^8.1 <= positions[i][1] <= 10^6.
这个题其实是求俄罗斯方块的最大高度。

可以用线段树，但是会超内存。因为不知道方块的右边界在哪。

网上看到的大神解法：

就是每当落入一个方块的时候，直接遍历求解这个区域的最高的高度，

在求解最高高度的时候，就是寻找公共区间来判断最高高度

class Solution
{
public:
    vector<int> fallingSquares(vector<pair<int, int>>& pos)
    {
        vector<int> res;
        vector<vector<int>> all; //存储所有的方块，但是高度是放置的高度
        int h = 0;
        for (auto p : pos)
        {
            vector<int> one = { p.first, p.first + p.second - 1, p.second };
            h = max(h, getHeight(all, one));
            res.push_back(h);
        }
        return res;
    }
    
    int getHeight(vector<vector<int>>& all, vector<int>& one)
    {
        int left = one[0], right = one[1];
        int maxHeight = 0;
        for (auto i : all)
        {
            if (left > i[1] || right < i[0])  //和当前遍历的没有一点重合
                continue;
            maxHeight = max(maxHeight, i[2]); //必须有重合才能往上 重叠    maxHeight代表这个区域已有的方块的最高的高度
        }
        one[2] += maxHeight;
        all.push_back(one);
        return one[2];
    }
};