[Leetcode Weekly Contest]306

本文主要是介绍[Leetcode Weekly Contest]306，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

链接：LeetCode

[Leetcode]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 矩阵中的最大值。
返回生成的矩阵。

循环模拟即可。如果把 \(3\times 3\) 改成一个比较大的 \(h\times w\)， 构建二维单调队列求解即可。

class Solution {
    public int arithmeticTriplets(int[] nums, int diff) {
        int res = 0;
        HashSet<Integer> set = new HashSet<>();
        for(var num:nums) set.add(num);
        for(var num:nums) {
            if(set.contains(num+diff) && set.contains(num+2*diff)) {
                res ++;
            }
        }
        return res;
    }
}

[Leetcode]2374. 边积分最高的节点

给你一个有向图，图中有 n 个节点，节点编号从 0 到 n - 1 ，其中每个节点都 恰有一条 出边。
图由一个下标从 0 开始、长度为 n 的整数数组 edges 表示，其中 edges[i] 表示存在一条从节点 i 到节点 edges[i] 的 有向 边。
节点 i 的 边积分 定义为：所有存在一条指向节点 i 的边的节点的 编号 总和。
返回 边积分 最高的节点。如果多个节点的 边积分 相同，返回编号 最小 的那个。

遍历，注意需要long类型。

class Solution {
    public int edgeScore(int[] edges) {
        int n = edges.length, res = 0;
        long[] score = new long[n];
        for(int i=0;i<n;++i) {
            score[edges[i]] += i;
        }

        for(int i=0;i<n;++i) {
            if(score[i] > score[res]) {
                res = i;
            }
        }
        return res;
    }
}

[Leetcode]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。

贪心。先将数组按自然序列排列好，默认升序.接下来只需要处理降序情况，扫到一系列'D'，就把D系列中的数字逆排序。这里关键的是，之所以可以通过贪心策略来排序，是因为我们分组处理后，后面组的数据不影响前面的结果。如，'IIIDDID'，这里'IIIDD'是一组，已经可得'123654'后面无论是什么都不影响前面的最佳顺序。

class Solution {
    public String smallestNumber(String pattern) {
        int n = pattern.length();
        String[] res = new String[n+1];
        for(int i=0;i<n+1;i++) {
            res[i] = "" + (char)('1'+i);
        }
        int i=0;
        while(i<n) {
            if(pattern.charAt(i) == 'I') {
                i++;
            } else {
                int start_ind = i;
                while(i<n && pattern.charAt(i) == 'D') {
                    i++;
                }
                reverseArray(res, start_ind, i);
            }
        }
        return String.join("", res);
    }

    private void reverseArray(String[] list, int start, int end) {
        while(start<=end) {
            String tmp = list[end];
            list[end] = list[start];
            list[start] = tmp;
            start ++;
            end --;
        }
    }
}

[Leetcode] 2376. 统计特殊整数

如果一个正整数每一个数位都是 互不相同 的，我们称它是 特殊整数 。
给你一个 正 整数 n ，请你返回区间 [1, n] 之间特殊整数的数目。

数位DP。
将 \(n\) 转换成字符串 \(s\)，定义 \(f(i,\textit{mask}, \textit{isLimit},\textit{isNum})\) 表示构造从左往右第 \(i\) 位及其之后数位的合法方案数，其余参数的含义为：

• \(\textit{mask}\) 表示前面选过的数字集合，换句话说，第 \(i\) 位要选的数字不能在 \(\textit{mask}\) 中。
• \(\textit{isLimit}\) 表示当前是否受到了\(n\) 的约束。若为真，则第 \(i\) 位填入的数字至多为 \(s[i]\)，否则可以是 \(9\)。如果在受到约束的情况下填了 \(s[i]\)，那么后续填入的数字仍会受到 \(n\) 的约束。
• \(\textit{isNum}\) 表示 \(i\) 前面的数位是否填了数字。若为假，则当前位可以跳过（不填数字），或者要填入的数字至少为 \(1\)；若为真，则要填入的数字可以从 \(0\) 开始。

后面两个参数可适用于其它数位 DP 题目。
枚举要填入的数字，具体实现逻辑见代码。
下面代码中 只需要记忆化 \((i,\textit{mask})\) 这个状态，因为：

• 对于一个固定的 \((i,\textit{mask})\)，这个状态受到 \(\textit{isLimit}\) 或 \(\textit{isNum}\) 的约束在整个递归过程中至多会出现一次，没必要记忆化。
• 另外，如果只记忆化 \((i,\textit{mask})\)，\(\textit{dp}\) 数组的含义就变成在不受到约束时的合法方案数，所以要在 !isLimit && isNum 成立时才去记忆化。

class Solution {
    int length;
    int[][] dp;
    String s;

    public int countSpecialNumbers(int n) {
        s = ""+n;
        length = s.length();
        dp = new int[length][1 << 10];
        for (var i = 0; i < length; i++) Arrays.fill(dp[i], -1);
        return dfs(0, 0, true, false);
    }

    public int dfs(int i, int mask, boolean isLimit, boolean isNum) {
        if(i == length) return isNum ? 1 : 0;
        if(!isLimit && isNum && dp[i][mask] >= 0) return dp[i][mask];

        dp[i][mask] = 0;
        if(!isNum) dp[i][mask] += dfs(i+1, mask, false, false);

        int up = isLimit ? (int)(s.charAt(i)-'0') : 9;
        int below = isNum ? 0 : 1;
        for(int val = below; val<up+1; val++) {
            if((mask & (1 << val)) == 0) dp[i][mask] += dfs(i+1, mask | (1<<val), isLimit && (val == up) ? true : false, true);
        }
        return dp[i][mask];
    }
}

参考：LeetCode

这篇关于[Leetcode Weekly Contest]306的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！