LeetCode - 803 打砖块

最新推荐文章于 2022-12-07 19:29:09 发布

原创最新推荐文章于 2022-12-07 19:29:09 发布 · 500 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

leetcode 专栏收录该内容

151 篇文章

订阅专栏

本文介绍了一种算法解决方案，用于在一个二维网格中，通过最少的步数消除给定的击打位置的砖块。使用并查集数据结构来跟踪区域合并，计算每个砖块消除所需的步数。核心部分涉及路径压缩和区域合并操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

class Solution {
    int row;
    int col;
    public static final int[][] DIRECTIONS = {{0,1},{0,-1},{-1,0},{1,0}};
    public int[] hitBricks(int[][] grid, int[][] hits) {
        row = grid.length;
        col = grid[0].length;
        int[][] copy = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                copy[i][j] = grid[i][j];
            }
        }
        //在copy中将墙击碎
        for(int i = 0;i < hits.length;i++)
           copy[hits[i][0]][hits[i][1]] = 0; 
        int size = row*col;
        UnionFind uf = new UnionFind(size+1);
        for(int i =0;i<col;i++){
           if(copy[0][i] == 1)
             uf.union(i,size);
        }
        for (int i = 1; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (copy[i][j] == 1) {
                    // 如果上方也是砖块
                    if (copy[i - 1][j] == 1) {
                        uf.union(getIndex(i - 1, j), getIndex(i, j));
                    }
                    // 如果左边也是砖块
                    if (j > 0 && copy[i][j - 1] == 1) {
                        uf.union(getIndex(i, j - 1), getIndex(i, j));
                    }
                }
            }
        }
        int[] res = new int[hits.length];
        for(int i =hits.length-1;i>=0 ;i--){
            int x = hits[i][0];
            int y = hits[i][1];
            if(grid[x][y] == 0)//本身就没有砖  跳过
                continue;
            int origin = uf.getSize(size);
            if(x == 0)
               uf.union(y,size);
            for(int j =0;j<DIRECTIONS.length;j++){
                int[] DIRECTION = DIRECTIONS[j];
                int newX = x + DIRECTION[0];
                int newY = y + DIRECTION[1];
                if(isArea(newX,newY) == true && copy[newX][newY] == 1){
                   uf.union(getIndex(newX,newY),getIndex(x,y));
                   //uf.union(getIndex(x,y),getIndex(newX,newY));
                }
            }
            int current = uf.getSize(size);
            res[i] = Math.max(0, current - origin - 1);
            // 真正补上这个砖块
            copy[x][y] = 1;
            
        }
        return res;   
    }
    private boolean isArea(int x, int y) {
        return x >= 0 && x < row && y >= 0 && y < col;
    }
    private int getIndex(int x, int y) {
        return x * col + y;
    }
    private class UnionFind {
        /**
         * 当前结点的父亲结点
         */
        private int[] parent;
        /**
         * 以当前结点为根结点的子树的结点总数
         */
        private int[] size;

        public UnionFind(int n) {
            parent = new int[n];
            size = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
                size[i] = 1;
            }
        }

        /**
         * 路径压缩，只要求每个不相交集合的「根结点」的子树包含的结点总数数值正确即可，因此在路径压缩的过程中不用维护数组 size
         *
         * @param x
         * @return
         */
        public int find(int x) {
            if (x != parent[x]) {
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }

        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);

            if (rootX == rootY) {
                return;
            }
            parent[rootX] = rootY;
            // 在合并的时候维护数组 size
            size[rootY] += size[rootX];
        }

        /**
         * @param x
         * @return x 在并查集的根结点的子树包含的结点总数
         */
        public int getSize(int x) {
            int root = find(x);
            return size[root];
        }
    }
}