leetcode第306场周赛(前三题)

记录：这次还不错，做对三道，只可惜第二题想的太复杂，用时太长还错了很多次。

第一题

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 矩阵中的最大值。

返回生成的矩阵。

示例 1：

输入：grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]
输出：[[9,9],[8,6]]
解释：原矩阵和生成的矩阵如上图所示。
注意，生成的矩阵中，每个值都对应 grid 中一个相接的 3 x 3 矩阵的最大值。

示例 2：

输入：grid = [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]]
输出：[[2,2,2],[2,2,2],[2,2,2]]
解释：注意，2 包含在 grid 中每个 3 x 3 的矩阵中。

提示：

    n == grid.length == grid[i].length
    3 <= n <= 100
    1 <= grid[i][j] <= 100

来源：力扣（LeetCode）
这道题暴力就好了，我当时还在想有没有好办法，但n这么小，暴力吧还是。

我对方向的实现用了两个数组，大家完全不用，就写一个3*3的遍历就好了。

AC代码：

class Solution {
public:
    vector<vector<int>> largestLocal(vector<vector<int>>& grid) {
        int n = grid[1].size();
        int dx[8]={-1,0,1,0,-1,-1,1,1};
        int dy[8]={0,1,0,-1,1,-1,1,-1};
        vector<vector<int>> ans;
        for(int i=1;i<n-1;i++){
            vector<int> g;
            for(int j=1;j<n-1;j++){
                int max=grid[i][j];
                for(int k=0;k<8;k++){
                    int x=i+dx[k],y=j+dy[k];
                    if(grid[x][y]>max)max=grid[x][y];
                }
                g.push_back(max);
            }
            ans.push_back(g);
        }
        return ans;
    }
    
};

第二题

6149. 边积分最高的节点

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

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

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

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

示例 1：

输入：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 。

示例 2：

输入：edges = [2,0,0,2]
输出：0
解释：
- 节点 1 和 2 都有指向节点 0 的边，节点 0 的边积分等于 1 + 2 = 3 。
- 节点 0 和 3 都有指向节点 2 的边，节点 2 的边积分等于 0 + 3 = 3 。
节点 0 和 2 的边积分都是 3 。由于节点 0 的编号更小，返回 0 。

提示：

    n == edges.length
    2 <= n <= 105
    0 <= edges[i] < n
    edges[i] != i

来源：力扣（LeetCode）

一开始我看这题像图论，还整了一个邻接表那一套，最后就是有2个测试点过不了，代码也很复杂，不放出来了，赛后仔细看看，还是做题的时候考虑的不周到，没有很好的理解题意，这道题只需要把每个点对应的积分记下来就可以了，用一个数组即可，注意会爆int（别问我怎么知道的）。

AC代码：

class Solution {
public:
    int edgeScore(vector<int>& edges) {
        int n = edges.size();
        vector<long long> ans(n);
        for(int i=0;i<n;i++){
            ans[edges[i]]+=i;
        }
        int res=0;
        for(int i=0;i<n;i++){
            if(ans[i]>ans[res])res=i;
        }
        return res;
    }
};

第三题

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：

输入：pattern = "IIIDIDDD"
输出："123549876"
解释：
下标 0 ，1 ，2 和 4 处，我们需要使 num[i] < num[i+1] 。
下标 3 ，5 ，6 和 7 处，我们需要使 num[i] > num[i+1] 。
一些可能的 num 的值为 "245639871" ，"135749862" 和 "123849765" 。
"123549876" 是满足条件最小的数字。
注意，"123414321" 不是可行解因为数字 '1' 使用次数超过 1 次。

示例 2：

输入：pattern = "DDD"
输出："4321"
解释：
一些可能的 num 的值为 "9876" ，"7321" 和 "8742" 。
"4321" 是满足条件最小的数字。

提示：

    1 <= pattern.length <= 8
    pattern 只包含字符 'I' 和 'D' 。

来源：力扣（LeetCode）

个人思路：

由于'D'需要降序，我们可以准备一个123456789，遇到'D'我们就逆序一下，当遇到多个'D'的时候，整体逆序一下就可以了。

AC代码：

class Solution {
public:
    void rev(string &s,int start,int end){
        if(s!=""){
            for(int i=start,j=end;i<j;i++,j--){
                char ch=s[i];
                s[i]=s[j];
                s[j]=ch;
            }
        }
    }
    string smallestNumber(string p) {
        int n = p.size();
        string ans = "0123456789";
        for(int i=0;i<n;i++){
            if(p[i]=='D'){
                int j=i;
                while(p[j]=='D')j++;
                if(i!=j)rev(ans,i+1,j+1);
                i=j;
            }
        }
        string res = ans.substr(1,n+1);
        return res;
    }
};