LeetCode 306周赛（补记）

最新推荐文章于 2022-11-02 20:31:27 发布

抠脚的大灰狼

最新推荐文章于 2022-11-02 20:31:27 发布

阅读量291

点赞数

分类专栏：算法算法周赛文章标签： leetcode 算法

本文链接：https://blog.csdn.net/vcj1009784814/article/details/126625119

版权

算法同时被 2 个专栏收录

120 篇文章 12 订阅

订阅专栏

算法周赛

34 篇文章 0 订阅

订阅专栏

文章目录

2373. 矩阵中的局部最大值

题目描述

给你一个大小为 n x n 的整数矩阵 grid 。

生成一个大小为 (n - 2) x (n - 2) 的整数矩阵 maxLocal ，并满足：

maxLocal[i][j] 等于 grid 中以 i + 1 行和 j + 1 列为中心的 3 x 3 矩阵中的最大值。
换句话说，我们希望找出 grid 中每个 3 x 3 矩阵中的最大值。

返回生成的矩阵。

思路

简单遍历即可

class Solution {

    int[] dx = {0, -1, 1, 0, 0, -1, -1, 1, 1};

    int[] dy = {0, 0, 0, 1, -1, -1, 1, -1, 1};

    public int[][] largestLocal(int[][] grid) {
        int n = grid.length;
        int[][] ans = new int[n - 2][n - 2];
        for (int i = 1; i < n - 1; i++) {
            for (int j = 1; j < n - 1; j++) {
                int u = 0;
                // 找到9个数中的最大值
                for (int k = 0; k < 9; k++) {
                    int ni = i + dx[k];
                    int nj = j + dy[k];
                    u = Math.max(u, grid[ni][nj]);
                }
                ans[i - 1][j - 1] = u;
            }
        }
        return ans;
    }
}

也可以

class Solution {
    public int[][] largestLocal(int[][] grid) {
        int n = grid.length;
        int[][] ans = new int[n - 2][n - 2];
        for (int i = 1; i < n - 1; i++) {
            for (int j = 1; j < n - 1; j++) {
                for (int x = i - 1; x <= i + 1; x++) {
                    for (int y = j - 1; y <= j + 1; y++) {
                        ans[i - 1][j - 1] = Math.max(ans[i - 1][j - 1], grid[x][y]);
                    }
                }
            }
        }
        return ans;
    }
}

扩展

如果把题目中的3 × 3改成比较通用的 H × W，该怎么做呢？

直接暴力求解就不可取了。总共有（n - W + 1）×（n - H + 1）个区域需要求解，如果每个区域内都使用穷举遍历，则每个区域求解的复杂度为H × W，整体复杂度就是（n - W + 1）×（n - H + 1）× H × W。

由于求解的区域固定了。其实就相当于用一个H × W 大的窗口，从左到右，从上到下，滑过整个矩阵，每滑到一个位置，求解一下当前窗口内的最大值。我们可以联想到一维的情况，给定一个固定长度的窗口，求解一个数组中，每个窗口大小的最值，我们使用的是单调队列。只不过这里变成了二维的窗口而已。

使用单调队列，先在行上做滑窗，再在列上做滑窗。

由于窗口是从左到右滑动，则对于每一行的数，我们从左到右遍历，并维护一个递减的单调队列，求出每个位置所在的长度为W的窗口中的最大值。

由于窗口从上到下滑动，则再对于每一列，从上到下遍历，维护一个递减的单调队列，求出每个位置所在的长度为H的窗口中的最大值。

class Solution {
	public int[][] largestLocal(int[][] grid) {
        // 行和列
		int n = grid.length, m = grid[0].length;
		int[][] temp = new int[n][m];
		int h = 3, w = 3;
		int[][] ans = new int[n - h + 1][m - w + 1];
		Deque<Integer> q = new LinkedList<>();
        // 先按行进行滑窗
		for (int i = 0; i < n; i++) {
			q.clear();
			for (int j = 0; j < m; j++) {
				while (!q.isEmpty() && grid[i][j] >= grid[i][q.peekLast()]) q.pollLast();
				while (!q.isEmpty() && j - q.peekFirst() >= w) q.pollFirst();
				q.offerLast(j);
                // 注意单调栈中维护的数据, 要对应取 grid 矩阵
                // 求得的结果, 保存到 temp
				temp[i][j] = grid[i][q.peekFirst()];
			}
		}

        // 再按列进行滑窗
		for (int j = 0; j < m; j++) {
			q.clear();
			for (int i = 0; i < n; i++) {
				while (!q.isEmpty() && temp[i][j] >= temp[q.peekLast()][j]) q.pollLast();
				while (!q.isEmpty() && i - q.peekFirst() >= h) q.pollFirst();
				q.offerLast(i);
                // 注意此时应该用到上面 按行滑窗的结果
                // 所以单调栈中维护的数据应该是 temp
                // 把按列滑窗的结果再更新回 grid
				grid[i][j] = temp[q.peekFirst()][j];
			}
		}
        // 最终的结果就是 grid
		// 每个窗口的最右下角的那个点, 就是这个窗口的最值
		for (int i = h - 1; i < n; i++) {
			for (int j = w - 1; j < m; j++) {
				ans[i - h + 1][j - w + 1] = grid[i][j];
			}
		}
		return ans;
	}
}

2374. 边积分最高的节点

题目描述

给你一个有向图，图中有 n 个节点，节点编号从 0 到 n - 1 ，其中每个节点都恰有一条出边。

图由一个下标从 0 开始、长度为 n 的整数数组 edges 表示，其中 edges[i] 表示存在一条从节点 i 到节点 edges[i] 的有向边。

节点 i 的边积分定义为：所有存在一条指向节点 i 的边的节点的编号总和。

返回边积分最高的节点。如果多个节点的边积分相同，返回编号最小的那个。

示例：

输入：edges = [1,0,0,0,0,7,7,5]
输出：7
解释：

节点 1、2、3 和 4 都有指向节点 0 的边，节点 0 的边积分等于 1 + 2 + 3 + 4 = 10 。
节点 0 有一条指向节点 1 的边，节点 1 的边积分等于 0 。
节点 7 有一条指向节点 5 的边，节点 5 的边积分等于 7 。
节点 5 和 6 都有指向节点 7 的边，节点 7 的边积分等于 5 + 6 = 11 。
节点 7 的边积分最高，所以返回 7 。

思路

简单题，考察哈希表。这里由于节点编号为0 ~ n-1，故可以直接开一个数组进行模拟。

class Solution {
    public int edgeScore(int[] edges) {
        int n = edges.length;
        int[] map = new int[n];
        int sum = 0, ans = -1;
        for (int i = 0; i < n; i++) {
            map[edges[i]] += i;
            if (map[edges[i]] > sum || (map[edges[i]] == sum && edges[i] < ans)) {
                sum = map[edges[i]];
                ans = edges[i];
            }
        }
        return ans;
    }
}

2375. 根据模式串构造最小数字

题目描述

给你下标从 0 开始、长度为 n 的字符串 pattern ，它包含两种字符，‘I’ 表示上升，‘D’ 表示下降。

你需要构造一个下标从 0 开始长度为 n + 1 的字符串，且它要满足以下条件：

num 包含数字 ‘1’ 到 ‘9’ ，其中每个数字至多使用一次。
如果 pattern[i] == ‘I’ ，那么 num[i] < num[i + 1] 。
如果 pattern[i] == ‘D’ ，那么 num[i] > num[i + 1] 。
请你返回满足上述条件字典序最小的字符串 num。

思路

要字典序最小，那么要尽可能的把较小的数字放到左边（贪心）。从数字1开始，当遇到I时，直接放置数字，当遇到D时，要保证当前位置放的数在满足递减条件时，尽可能小，那么我们用一个栈来暂存数字，并往后遍历，当遇到D后，第一次遇到I，或者到达末尾时，便可将栈中的数字依次弹出并填充到对应位置。

class Solution {
    public String smallestNumber(String pattern) {
        int[] stack = new int[10];
        int top = -1;
        int cur = 1;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            if (c == 'I') {
                sb.append(cur);
                while (top >= 0) sb.append(stack[top--]);
            } else {
                stack[++top] = cur;
            }
            cur++;
        }
        sb.append(cur);
        while (top >= 0) sb.append(stack[top--]);
        return sb.toString();
    }
}

2376. 统计特殊整数

题目描述

如果一个正整数每一个数位都是 互不相同 的，我们称它是 特殊整数 。

给你一个正整数 n ，请你返回区间 [1, n] 之间特殊整数的数目。

思路

数位统计，分类讨论。

我们设这个数为num，它一共有n位，在[1,num]区间内的数，我们可以将其分为两类：

位数为n的数
位数小于n的数

对于位数小于n的数，我们可以非常直接的套用数学公司求解特殊整数的数目。

举个例子，设num = 428571，这个数有6位，我们的求解过程可以分类讨论

位数恰好为6位的，且小于等于num的数中，特殊整数的数目
位数不足6位的，特殊整数的数目

对于位数不足6位的，非常好求。我们进一步将这些数，按照位数进行分类

位数为1的数
位数为2的数
位数为3的数
位数为4的数
位数为5的数

我们只需要分别求一下上面这几类数当中，特殊整数的数目即可。

比如对于位数为5的数，我们首先看最高位，最高位不能取0，可以取1 - 9，共9个数。次高位本身可以取0 - 9共10个数，但由于最高位用掉了1个数，而特殊整数要求每一位上的数不能重复，则次高位只能取 10 - 1 = 9个数，同理，第3位能取8个数（前面2位分别用掉了2个数，10 - 2 = 8）。

所以位数为5的数当中，所有特殊整数的个数即为：9 × 9 × 8 × 7 × 6

更为一般性地，位数为k的数当中，所有特殊整数的个数为：9 × 9 × 8 ×7 × 6 × … × （10 - k + 1）

当然，当10 - k + 1 >= 0 时，是一定会存在重复数字的，毕竟一共就10给数字，显而易见的，当位数等于10时，0 - 9这10个数恰好在每一位上都出现一次，当位数大于10时，一定不存在特殊整数了。

那么对于数num，其位数为n，我们先使用公式，直接计算出位数为[1, n - 1]时的特殊整数的个数。

随后来单独考虑位数为n的数。还是以上面的数字428571为例。

先考虑最高位，num的最高位为4，我们先考虑最高位取1到3的那些数，对于这些数，后面剩余位置上的数字可以随便填。

位数一共是6，第一位从[1, 3]随便取一个数字，那么后面还剩5个位置，随便填，即是 9 × 8 × 7 × 6 × 5。

随后我们固定第一位为4，再看第二位，原数字的第二位是2，那么先考虑0到1中的数，对于这些数，后面剩余4个位置可以随便填。

由于前面填了2个位，用掉2个数，所以剩8个数，而后面剩4个位置，则是 8 × 7 × 6 × 5。

接着，固定第二位为2，看第三位，原数字第三位是8，那么先考虑0到7中的数，对于这些数，后面剩余3个位置可以随便填，即 7 × 6 × 5。但此时要注意，因为前两位已经填了42，则第三位考虑0到7中的数时，需要跳过2和4。

接着，固定第三位为8，考虑第四位，先考虑0到4，同样的，由于前面三位已经填了428，所以0到4中，需要跳过2和4。

接着，固定第四位为5，… 就不再赘述。这个过程用图形来表示，就是一颗树，如下：

在这里插入图片描述

class Solution {
    public int countSpecialNumbers(int n) {
        List<Integer> bits = new ArrayList<>();
        // 求出每一位上的数字
        while (n > 0) {
            bits.add(n % 10);
            n /= 10;
        }
        n = bits.size();
        // 1 ~ n - 1 位
        // 第 k 位时, 特殊整数的个数 =  9 * 9 * 8 * 7 * 6 * ....
        int ans = 0;
        for (int i = 1; i <= n - 1; i++) {
            int t = 9;
            // 由于数据范围是 2 × 10^9, 所以严格来说是不需要 j < 10 这个判断的
            for (int j = 1; j < i && j < 10; j++) t *= 10 - j;
            ans += t;
        }
        // 第 1 ~ n - 1 位数字, 都可以用这个公式统计出来
        // 对于位数恰好是 n 的, 从最高位开始进行分类讨论
        boolean[] st = new boolean[10]; // 用作标记已经使用的数字
        // 需要从最高位开始进行统计
        for (int i = n - 1; i >= 0; i--) {
            int begin = i == n - 1 ? 1 : 0; // 第一位数字不能取0, 要从1开始取, 后续的数字可以从0开始取
            // 这一位上的数字为 x = bits[i], 对于从0取到x - 1, 后面的位置可以随便取
            for (int j = begin; j < bits.get(i); j++) {
                if (st[j]) continue; // 这个数字出现过, 不能进行统计, 需要跳过
                // 一共有多少个位置已经被填充了? n - i , 还剩多少个位置? i 
                // 剩余位置的第一个位置能填的数字个数
                int x = 10 - (n - i);
                if (i > x) continue; // 若剩余的位置大于x, 则一定会出现重复, 这题的数据范围不需要这个判断
                int t = 1;
                for (int k = 0; k < i; k++, x--) t *= x;
                ans += t;
            }
            // 该位置上 0 ~ x - 1都枚举过来, 枚举 x 这个数本身
            if (st[bits.get(i)]) break; //这个位置是否能填这个数, 若不能填, 则直接结束, 相当于这个分支被剪枝了
            st[bits.get(i)] = true; // 把这个位置的数填上去, 标记下这个数字被用过了
        }
        // 由于上面的不会枚举到n这个数本身, 所以需要特判一下n这个数本身
        st = new boolean[10];
        boolean flag = true;
        for (int i : bits) {
            if (st[i]) {
                flag = false;
                break;
            }
            st[i] = true;
        }
        if (flag) ans++; // 加上n这个数本身
        return ans;
    }
}

数位DP的题目，参考ACWING算法提高课部分 -> B站试听课链接

本次周赛战绩：
在这里插入图片描述

总结

这次周赛题目总体难度不算特别大，第一题卡了一下，一开始以为要用二维滑窗来做，后来发现暴力即可；第二题简单题；第三题运气较好，一开始就想了栈；第四题有机会做出来，但是分类讨论时脑子绕进去了没出来，比较可惜。

继续加油！

抠脚的大灰狼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode 306周赛（补记）

这次周赛题目总体难度不算特别大，第一题卡了一下，一开始以为要用二维滑窗来做，后来发现暴力即可；第二题简单题；第三题运气较好，一开始就想了栈；第四题有机会做出来，但是分类讨论时脑子绕进去了没出来，比较可惜。继续加油！...
复制链接

扫一扫