LeetCode-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.

Analysis:

1. Using bfs, regular soltion.

2. Using binary search: the left most col with 1, the right most col with 1, the up most row with 1, the low most row with 1. Much faster.

Solution 1:

public class Solution {
    int[][] moves = new int[][] {{1,0},{-1,0},{0,1},{0,-1}};
    public int minArea(char[][] image, int x, int y) {
        if (image.length==0 || image[0].length==0) return 0;
        
        int rows = image.length, cols = image[0].length;
        int up = x, low = x, left = y, right = y;
        Queue<int[]> pixels = new LinkedList<int[]>();
        pixels.add(new int[]{x,y});
        
        while (!pixels.isEmpty()){
            // Get head pixel
            int[] head = pixels.poll();

            // Add its neighbors into queue. 
            for (int i=0;i<4;i++){
                int[] neighbor = new int[]{head[0]+moves[i][0],head[1]+moves[i][1]};
                if (neighbor[0]>=0 && neighbor[0]<rows && neighbor[1]>=0 && neighbor[1]<cols && image[neighbor[0]][neighbor[1]] == '1'){
                    pixels.add(neighbor);
                    image[neighbor[0]][neighbor[1]] = '2';
                    // update bounds
                    up = Math.min(up,neighbor[0]);
                    low = Math.max(low,neighbor[0]);
                    left = Math.min(left,neighbor[1]);
                    right = Math.max(right,neighbor[1]);
                }
            }
        }

        // Calculate area
        int res = (low-up+1) * (right-left+1);
        return res;
    }


}

Solution 2:

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

        int left = searchBoundary(image,0,y-1,true,true);
        int right = searchBoundary(image,y+1,image[0].length-1,true,false);
        int up = searchBoundary(image,0,x-1,false,true);
        int low = searchBoundary(image,x+1,image.length-1,false,false);

        return (right-left+1) * (low-up+1);
    }

    public int searchBoundary(char[][] image, int start, int end, boolean horizon, boolean lowerDirect){
        int iterBound = (horizon) ? image.length : image[0].length;
        while (start<=end){
            int mid = start + (end - start)/2;
            boolean hasOne = false;
            for (int i=0;i<iterBound;i++){
                char target = (horizon) ? image[i][mid] : image[mid][i];
                if (target=='1'){
                    hasOne = true;
                    break;
                }
            }

            if ( (hasOne && lowerDirect) || (!hasOne && !lowerDirect)){
                end = mid-1;
            } else {
                start = mid+1;
            }
        }
        return (lowerDirect) ? start : start-1;            
    }
}