leetcode做题笔记

题目

1020. 飞地的数量

描述

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

 

示例 1：

输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]] 输出：3 解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。 示例 2：

输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]] 输出：0 解释：所有 1 都在边界上或可以到达边界。

来源：力扣（LeetCode） 链接：leetcode.cn/problems/nu… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

AC CODE

直接粘的官方题解。

class Solution {
public:
    vector<vector<int>> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    int numEnclaves(vector<vector<int>>& grid) {
        this->m = grid.size();
        this->n = grid[0].size();
        this->visited = vector<vector<bool>>(m, vector<bool>(n, false));
        for (int i = 0; i < m; i++) {
            dfs(grid, i, 0);
            dfs(grid, i, n - 1);
        }
        for (int j = 1; j < n - 1; j++) {
            dfs(grid, 0, j);
            dfs(grid, m - 1, j);
        }
        int enclaves = 0;
        for (int i = 1; i < m - 1; i++) {
            for (int j = 1; j < n - 1; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    enclaves++;
                }
            }
        }
        return enclaves;
    }

    void dfs(const vector<vector<int>> & grid, int row, int col) {
        if (row < 0 || row >= m || col < 0 || col >= n || grid[row][col] == 0 || visited[row][col]) {
            return;
        }
        visited[row][col] = true;
        for (auto & dir : dirs) {
            dfs(grid, row + dir[0], col + dir[1]);
        }
    }
private:
    int m, n;
    vector<vector<bool>> visited;
};

思路

这种走格子的题，优先考虑DFS，根据示例可知道，一旦某个格子与边界上的为1的格子连接，则这个格子就不能计数。则官方题解中先对四个边界使用DFS遍历，并使用visited数组记录是否访问过，如果搜到连着的格子也是1，则对其所处位置的visited数组进行标记，最终将为grid为1，则没有访问过的格子进行计数。

日期

2023/03/20

题目

1315. 祖父节点值为偶数的节点和

描述

给你一棵二叉树，请你返回满足以下条件的所有节点的值之和： 该节点的祖父节点的值为偶数。（一个节点的祖父节点是指该节点的父节点的父节点。） 如果不存在祖父节点值为偶数的节点，那么返回 0 。 示例：

输入：root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5] 输出：18 解释：图中红色节点的祖父节点的值为偶数，蓝色节点为这些红色节点的祖父节点。

AC CODE

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int fillVec(TreeNode* root) {
        int result = 0;
        queue<TreeNode *> myQueue;
        myQueue.push(root);
        while(!myQueue.empty()) {
            TreeNode *tempNode = myQueue.front();
            myQueue.pop();
            if (tempNode->val % 2 == 0) {
                if (tempNode->left) {
                    if (tempNode->left->left) {
                        result += tempNode->left->left->val;
                    }
                    if (tempNode->left->right) {
                        result += tempNode->left->right->val;
                    }
                }
                if (tempNode->right) {
                    if (tempNode->right->left) {
                        result += tempNode->right->left->val;
                    }
                    if (tempNode->right->right) {
                        result += tempNode->right->right->val;
                    }
                }               
            }
            if (tempNode->left) myQueue.push(tempNode->left);
            if (tempNode->right) myQueue.push(tempNode->right);
        }
        return result;
    }
    int sumEvenGrandparent(TreeNode* root) {
        return fillVec(root);
    }
};

思路

这个题的思路在于如果当前节点为偶数，则依次对当前节点的左右节点的子节点进行存在性判断并累加。然后继续加入左右节点。

日期

2023/03/21

模板

题目

2415. 反转二叉树的奇数层

leetcode.cn/problems/re…

描述

有点复杂就不粘贴了

AC CODE

class Solution {
public:
    void helpFunc(TreeNode *left, TreeNode *right, int layer) {
        if (left == NULL && right == NULL) {
            return;
        }
        if (layer % 2 == 1) {
            int temp = left->val;
            left -> val = right->val;
            right->val = temp;
        }
        helpFunc(left->left, right->right, layer + 1);
        helpFunc(right->left, left->right, layer + 1);
    }
    TreeNode* reverseOddLevels(TreeNode* root) {
        helpFunc(root->left, root->right, 1);
        return root;
    }
    vector<vector<int>> vec;
};

思路

如果是奇数层，就交换对称节点的数值。

日期

2023年3月27日

2023年4月10日 1375已AC

2161

思路，使用了三个数组，分别是大于/等于/小于pivot的，遍历现有数组后，将三个数组拼接起来。

524. 通过删除字母匹配到字典里最长单词

思路：1.遍历dic数组，使用一个下标pos记录指向dic数组中某一元素_s的下标。 2. 遍历s，若匹配上了，则将pos加一，若pos等于_s的长度，说明匹配上了，则保存起来。 3. 对保存结果的vector进行排序，然后将第一个数据返回。

2094 留着明天做 20230420

2418. 按身高排序

先把输入数据用结构体整合起来，然后用sort和lamba表达式排序即可。

class Solution {
public:
    struct Data {
        string name;
        int height;
    };

    vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
        int m_size = names.size();
        vector<Data> data_vec(m_size);
        vector<string> resVec;
        for (int i = 0; i < m_size; i++) {
            data_vec[i].name = names[i];
            data_vec[i].height = heights[i];
        }
        sort(data_vec.begin(), data_vec.end(), [](Data &A, Data &B){
            return A.height > B.height;
        });

        for (auto i : data_vec) {
            resVec.push_back(i.name);
        }
        return resVec;
    }

};

模板

题目

描述

AC CODE

思路

日期