【leetcode】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.

样例：

given the following image:

[

"0010",

"0110",

"0100"

]

and x = 0, y = 2,

Return 6.

解析

求最小覆盖矩形面积

有一个矩阵，由0，1组成，每个1表示一个黑色像素点，

给出第一个黑色像素的位置，求最小的可以覆盖这个矩阵中黑色像素点的矩形大小

思路

一：遍历整个矩阵（缺点，如果矩阵很大，像素点占比很少，则比较浪费）

二：遍历像素点

找出最大最小的x，最大最小的y然后计算矩阵大小

解法

BFS广度有限算法（Queue）

用给出的一个像素点，利用queue，入队第一个像素点，然后入队它上下左右的像素；当队不空时继续遍历，直到所有的像素都遍历一遍

public int minAreaBFS(int[][] image, int x, int y) {
        if (image == null || image.length <= 0 || image[0] == null || image[0].length <= 0) {
            return 0;
        }
        int minX = x, minY = y, maxX = x, maxY = y;
        Queue<Point> queue = new LinkedList<>();
        Point rootP = new Point(x, y);
        queue.offer(rootP);
        //队不空时就继续
        while (!queue.isEmpty()) {
            Point p = queue.poll();
            minX = Math.min(p.x, minX);
            minY = Math.min(p.y, minY);
            maxX = Math.max(p.x, maxX);
            maxY = Math.max(p.y, maxY);
            //判断四周是否有像素,有就入队
            check(p.x - 1, p.y, image, queue);
            check(p.x + 1, p.y, image, queue);
            check(p.x, p.y - 1, image, queue);
            check(p.x, p.y + 1, image, queue);
        }
        return (maxX - minX + 1) * (maxY - minY + 1);
    }

    private void check(int x, int y, int[][] image, Queue queue) {
        int maxR = image.length;
        int maxC = image[0].length;
        Point p = new Point(x, y);
        if (x >= 0 && x < maxR && y >= 0 && y < maxC && image[x][y] == 1) {
            //遍历过的点置0
            image[x][y] = 0;
            queue.offer(p);
        }
    }

DFS深度优先算法（递归）

用给出的第一个点，递归遍历它的上下左右像素，直到遍历完所有的像素点

public int minAreaDFS(int[][] image, int x, int y) {
        if (image == null || image.length <= 0 || image[0] == null || image[0].length <= 0) {
            return 0;
        }
        //数组记录最小x，最小y，最大x，最大y
        int[] res = {x, y, x, y};
        dfs(x, y, image, res);
        return (res[2] - res[0] + 1) * (res[3] - res[1] + 1);
    }

    private void dfs(int x, int y, int[][] image, int[] res) {
        int maxR = image.length;
        int maxC = image[0].length;
        //若当前点存在且为像素，才继续，否则返回
        if (x >= 0 && x < maxR && y >= 0 && y < maxC && image[x][y] == 1) {
            image[x][y] = 0;
            res[0] = Math.min(x, res[0]);
            res[1] = Math.min(y, res[1]);
            res[2] = Math.max(x, res[2]);
            res[3] = Math.max(y, res[3]);
            dfs(x - 1, y, image, res);
            dfs(x + 1, y, image, res);
            dfs(x, y - 1, image, res);
            dfs(x, y + 1, image, res);
        }
    }