Leetcode 554 - Brick Wall（HashMap）

题意

一个m行的墙，每行由若干个大小不一的砖垒起来的。

现在要求找：一条线竖着穿过这面墙，并且穿过最少的砖（横穿，从砖的边上穿过不算）。

思路

首先，最直接的思路是枚举一下横着穿过的坐标，但是宽度最大到INT_MAX，所以不行。

因为所有的砖最多只有只有20000个，所以我们可以枚举砖的边缘。

算法1

枚举每一行的所有砖的边缘$x$，然后判断从这个地方切开会划开几个砖。

在求会划开几个砖的时候：维护每一行砖的前缀和，然后二分查找$x$是否在这个前缀和里面。

算法2

我们考虑能够优化算法1的时间复杂度。

对于第一行，假设我们第三个砖的边缘是5，第二行第2个砖的边缘是5。假设我们从第三行的某个砖的边缘（也是5）切开的：那么会刚好穿过第一行和第二行的某个转的边缘。即从哪一行穿过并没有影响，影响的只是边缘为5的有多少个。

并且，我们知道：对于一行，不会有两个砖同时共享一个相同的边缘值。

所以，就可以得到我们的算法：

用一个HashMap存储每一个砖的边缘值到那个砖所在行的起点的长度为 x <script type="math/tex" id="MathJax-Element-3">x</script>的有多少个。然后找出最大的一个即可。

代码

algorithm 1

class Solution {
public:
    int leastBricks(vector<vector<int>>& wall) {
        int m = wall.size(), res = 0;
        if (m) {
            int n = wall[0].size();
            if (n) {
                vector<vector<int>> sum(m);
                for (int i = 0; i < m; i++) {
                    sum[i].push_back(wall[i][0]);
                    for (int j = 1; j < wall[i].size(); j++) {
                        sum[i].push_back(sum[i].back() + wall[i][j]);
                    }
                }
                for (int i = 0; i < m; i++) {
                    for (int j = 0; j < sum[i].size() - 1; j++) {
                        int x = sum[i][j], cnt = 0;
                        for (int i = 0; i < m; i++) {
                            int pos = lower_bound(sum[i].begin(), sum[i].end(), x) - sum[i].begin();
                            if (pos < sum[i].size() && sum[i][pos] == x) cnt++;
                        }
                        res = max(res, cnt);
                    }
                }
                return m - res;
            }
            if (n == 0) return 0;
            return m;
        }
        return 0;
    }
};

algorithm 2

class Solution {
public:
    int leastBricks(vector<vector<int>>& wall) {
        unordered_map<int, int> has;
        int m = wall.size(), res = wall.size();
        for (auto rows : wall) {
            int sum = 0;
            for (int i = 0; i < rows.size() - 1; i++) {
                sum += rows[i];
                has[sum]++;
                res = min(res, m - has[sum]);
            }
        }
        return res;
    }
};