Leetcode刷题 2021.01.11

Leetcode1202 交换字符串中的元素

给你一个字符串 s，以及该字符串中的一些「索引对」数组 pairs，其中 pairs[i] = [a, b] 表示字符串中的两个索引（编号从 0 开始）。

你可以 任意多次交换 在 pairs 中任意一对索引处的字符。

返回在经过若干次交换后，s 可以变成的按字典序最小的字符串。

今天的每日一题，好像这几天很喜欢考并查集。思路还是比较好想，因为可以无限交换，所以如果是连通的就归为一类，按字典序排序就行了。其实个人感觉并查集就是聚类，最后查看有几类，类中有哪些元素就行了。

class Solution {
    public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
        int n = s.length();
        //并查集
        UninonFind uf = new UninonFind(n);
        //合并
        for(List<Integer> list : pairs){
            uf.union(list.get(0), list.get(1));
        }
        //再压缩一次，确保类中每个元素都指向root
        for(int i = 0; i < n; i++){
            uf.find(i);
        }
        //用一个map来记录类的root，优先队列进行排序
        Map<Integer, PriorityQueue<Character>> map = new HashMap<>();
        char[] arr = s.toCharArray();
        for(int i = 0; i < n; i++){
            int root = uf.parent[i];
            if (map.containsKey(root)){
                map.get(root).offer(arr[i]);
            }else{
                 PriorityQueue<Character> queue = new PriorityQueue<>();
                 queue.offer(arr[i]);
                 map.put(root, queue);
            }
        }
        //从map里面poll()出来即可
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < n; i++){
            int root = uf.parent[i];
            sb.append(map.get(root).poll());
        }
        return sb.toString();
        
    }
    class UninonFind{
        int[] parent;

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

        private int find(int i){
            if (parent[i] == i){
                return parent[i];
            }
            return parent[i] = find(parent[i]);
        }

        private void union(int i, int j){
            int root1 = find(i);
            int root2 = find(j);
            if (root1 == root2) return;
            parent[root1] = root2;
        }
    }
}

Leetcode1277 统计全为 1 的正方形子矩阵

给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。

好像和之前做的一道也是正方形的题很类似。一开始用O(n^3)的方法做出来的，结果一看只打败5%，看了题解，收获不少，改进到O(n2)（这个n平方打不出来不知道什么情况）。其实解法和之前那道题一样，对于一个右下角的正方形考虑上左三个元素的情况。

class Solution {
    public int countSquares(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        int[][] dp = new int[m][n];
        int res = 0;
        //边界初始化
        for(int i = 0; i < m; i++){
            dp[i][0] = matrix[i][0];
            if (dp[i][0] == 1) res++;
        }
        for(int i = 0; i < n; i++){
            dp[0][i] = matrix[0][i];
            if (dp[0][i] == 1) res++;
        }
        //多加了一次，减一个
        if (matrix[0][0] == 1) res--;

        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
            //状态转移方程，对于一个来说和周围三个有关，并且一个大小为3的正方形一定包含一个大小为2和一个大小为1的正方形
                if (matrix[i][j] == 1){
                    dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
                    res += dp[i][j];
                }
            }
        }

        return res;
    }
}

Leetcode1314 矩阵区域和

给你一个 m * n 的矩阵 mat 和一个整数 K ，请你返回一个矩阵 answer ，其中每个 answer[i][j] 是所有满足下述条件的元素 mat[r][c] 的和：

i - K <= r <= i + K, j - K <= c <= j + K
(r, c) 在矩阵内。

对于这种二维要求区域范围值得问题，一般都是前缀和。之前做过一道差不多的，二维数组检索与求和吧好像是。这题也是差不多的思路，最后计算值得时候要考虑好多边界条件，不想想了，直接拿官方题解的代码抄一抄了。-_-||

class Solution {
    public int[][] matrixBlockSum(int[][] mat, int K) {
        int m = mat.length, n = mat[0].length;
        //多申请一行一列，可以避免考虑边界复杂的情况
        int[][] help = new int[m + 1][n + 1];
        for(int i = 1; i < m + 1; i++){
            for(int j = 1; j < n + 1; j++){
                help[i][j] = help[i - 1][j] + help[i][j - 1] - help[i - 1][j - 1] + mat[i - 1][j - 1];
            }
        }

        int[][] res = new int[m][n];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                res[i][j] = get(help, m, n, i + K + 1, j + K + 1) - get(help, m, n, i - K, j + K + 1) - get(help, m, n, i + K + 1, j - K) + get(help, m, n, i - K, j - K);
            }
        }
        return res;
    }

    private int get(int[][] help ,int m, int n, int x, int y){
        x = Math.max(Math.min(x, m), 0);
        y = Math.max(Math.min(y, n), 0);
        return help[x][y];
    }
}