554. Brick Wall

There is a brick wall in front of you. The wall is rectangular and has several rows of bricks. The bricks have the same height but different width. You want to draw a vertical line from the top to the bottom and cross the least bricks.

The brick wall is represented by a list of rows. Each row is a list of integers representing the width of each brick in this row from left to right.

If your line go through the edge of a brick, then the brick is not considered as crossed. You need to find out how to draw the line to cross the least bricks and return the number of crossed bricks.

You cannot draw a line just along one of the two vertical edges of the wall, in which case the line will obviously cross no bricks.

Example:

Input: [[1,2,2,1],
[3,1,2],
[1,3,2],
[2,4],
[3,1,2],
[1,3,1,1]]

Output: 2

Explanation:

Note:

1. The width sum of bricks in different rows are the same and won’t exceed INT_MAX.
2. The number of bricks in each row is in range [1,10,000]. The height of wall is in range [1,10,000]. Total number of bricks of the wall won’t exceed 20,000.

方法1：hash

思路：

用hash来计数presum在各个层出现的次数，最后要return的就是wall.size() - 出现次数最多的presum。

Complexity

Time complexity: O(n), n 是brick的总数。
Space complexity: O(m), m 是wall width。

class Solution {
public:
    int leastBricks(vector<vector<int>>& wall) {
        unordered_map<int, int> hash;
        int res = 0;
        for (auto l: wall) {
            int presum = 0;
            for (int i = 0; i < l.size() - 1; i++) {
                presum += l[i];
                hash[presum]++;
                res = max(res, hash[presum]);
            }
        }
        return wall.size() - res;
    }
};

方法2: sweep line (sort of)

思路：

类似于sweep line的做法，但是是collapsed版本，不需要priority queue来记录事件s，e，因为每一个点，除了开始和结束，同时s，e。所以我们只要记录除首尾的位置每个点发生event的数量就行。这个位置要通过presum累加。得到hash之后，我们首先将res初始化为n（最多也就穿n层），然后一个count，每一次事件发生的瞬间，将所有缝隙减去，计算是否能达到最小，再把缝隙都加回去。

易错点：

1. 初始化必须是n：[[1],[1],[1]]这种情况不存在中间事件，res会被直接返回。
2. 最后一个edge，也就是墙结束的地方不能参与计算。

class Solution {
public:
    int leastBricks(vector<vector<int>>& wall) {
        map<int, int> hash;
        for (auto layer: wall) {
            int pos = 0;
            for (int brick: layer) {
                pos += brick;
                hash[pos]++;
            }
        }
        int res = wall.size(), count = wall.size();
        for (auto it = hash.begin(); it != prev(hash.end()); it++) {
            count -= ((*it).second);           
            res = min(res, count);
            count += ((*it).second);
        }
        return res;
        
    }
};