302. Smallest Rectangle Enclosing Black Pixels

题目：

An image is represented by a binary matrix with 0 as a white pixel and 1 as a black pixel. The black pixels are connected, i.e., there is only one black region. Pixels are connected horizontally and vertically. Given the location (x, y) of one of the black pixels, return the area of the smallest (axis-aligned) rectangle that encloses all black pixels.

For example, given the following image:

[
  "0010",
  "0110",
  "0100"
]

and x = 0, y = 2, 

Return 6.

链接：https://leetcode.com/problems/smallest-rectangle-enclosing-black-pixels/#/description

4/25/2017

2ms, 47%

算法班

用4个二分法查找四个边界。比如查找left时候每次mid其实都要把所有row在mid column的值过一遍。

非常需要注意细节，x,y都是用来确定row还是column的

面试有时间可以refactor代码

public class Solution {
    public int minArea(char[][] image, int x, int y) {
        if (image == null || image.length == 0 || image[0].length == 0) return 0;

        int left, right, top, bottom;

        int start = 0, end = y;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (checkThisColumn(image, mid)) {
                end = mid;
            } else {
                start = mid;
            }
        }

        if (checkThisColumn(image, start)) {
            left = start;
        } else {
            left = end;
        }

        start = y;
        end = image[0].length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (checkThisColumn(image, mid)) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (checkThisColumn(image, end)) {
            right = end;
        } else {
            right = start;
        }

        start = 0;
        end = x;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (checkThisRow(image, mid)) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (checkThisRow(image, start)) {
            top = start;
        } else {
            top = end;
        }

        start = x;
        end = image.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (checkThisRow(image, mid)) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (checkThisRow(image, end)) {
            bottom = end;
        } else {
            bottom = start;
        }
        return (right - left + 1) * (bottom - top + 1);
    }

    private boolean checkThisRow(char[][] image, int index) {
        if (image == null || image.length == 0 || image[0].length == 0) return false;

        for(int i = 0; i < image[0].length; i++) {
            if (image[index][i] == '1') return true;
        }
        return false;
    }

    private boolean checkThisColumn(char[][] image, int index) {
        if (image == null || image.length == 0 || image[0].length == 0) return false;
        for(int i = 0; i < image.length; i++) {
            if (image[i][index] == '1') return true;
        }
        return false;
    }
}

别人refactor的代码是很好看的

https://discuss.leetcode.com/topic/29006/c-java-python-binary-search-solution-with-explanation

private char[][] image;
public int minArea(char[][] iImage, int x, int y) {
    image = iImage;
    int m = image.length, n = image[0].length;
    int top = search(0, x, 0, n, true, true);
    int bottom = search(x + 1, m, 0, n, false, true);
    int left = search(0, y, top, bottom, true, false);
    int right = search(y + 1, n, top, bottom, false, false);
    return (right - left) * (bottom - top);
}
private boolean isWhite(int mid, int k, boolean isRow) {
    return ((isRow) ? image[mid][k] : image[k][mid]) == '0';
}
private int search(int i, int j, int low, int high, boolean opt, boolean isRow) {
    while (i != j) {
        int k = low, mid = (i + j) / 2;
        while (k < high && isWhite(mid, k, isRow)) ++k;
        if (k < high == opt)
            j = mid;
        else
            i = mid + 1;
    }
    return i;
}
//  Runtime: 2 ms

Python活教材

https://discuss.leetcode.com/topic/29086/clear-binary-search-python

def minArea(self, image, x, y):
    def first(lo, hi, check):
        while lo < hi:
            mid = (lo + hi) / 2
            if check(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo
    top    = first(0, x,             lambda x: '1' in image[x])
    bottom = first(x, len(image),    lambda x: '1' not in image[x])
    left   = first(0, y,             lambda y: any(row[y] == '1' for row in image))
    right  = first(y, len(image[0]), lambda y: all(row[y] == '0' for row in image))
    return (bottom - top) * (right - left)

官方解答：

https://leetcode.com/articles/smallest-rectangle-enclosing-black-pixels/

DFS也可以做，但是不如二分法好，DFS的意思是把访问过的1设为0，然后想4个方向去发展检查。

更多讨论：

https://discuss.leetcode.com/category/381/smallest-rectangle-enclosing-black-pixels