leetcode刷题记录10（2023-06-25）【岛屿数量(并查集) | 反转链表(注意考虑空链表边界情况) | 课程表(拓扑排序) | 实现 Trie(前缀树，一种用于自动补完等的数据结构)】

Cherries Man

已于 2024-01-10 16:40:22 修改

阅读量898

点赞数 26

分类专栏：刷题笔记文章标签：数据结构 leetcode 链表

于 2023-12-31 09:56:15 首次发布

本文链接：https://blog.csdn.net/myf_666/article/details/131379343

版权

刷题笔记专栏收录该内容

53 篇文章 0 订阅

订阅专栏

200. 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：
输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1

示例 2：
输入：grid = [
[“1”,“1”,“0”,“0”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“1”,“0”,“0”],
[“0”,“0”,“0”,“1”,“1”]
]
输出：3

提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 ‘0’ 或 ‘1’

这道题目也是一遍就过了，说实话感觉并不是很简单，感觉很有成就感！！

在这里插入图片描述

主要思路就是利用并查集，将所有岛屿合并到一个集合里面。

最后遍历并查集，看看有多少个内部元素为 ‘1’ 的集合。

代码如下：

#include<vector>

using namespace std;

class UFSets {
public:
    vector<int> vec;

    UFSets(int sz) {
        vec = vector<int>(sz, -1);
    }
    int Find(int x) {
        while (vec[x] > 0)x = vec[x];
        return x;
    }
    bool Union(int root1, int root2) {
        int r1 = Find(root1);
        int r2 = Find(root2);
        if (r1 == r2) {
            return false;
        }
        if (vec[r2] < vec[r1]) {
            vec[r2] = vec[r1] + vec[r2];
            vec[r1] = r2;
        }
        else {
            vec[r1] = vec[r1] + vec[r2];
            vec[r2] = r1;
        }
        return true;
    }
};

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        UFSets ufset(grid.size() * grid[0].size());

        for (int i = 0; i < grid.size(); i++) {

            for (int j = 0; j < grid[0].size(); j++) {

                if (grid[i][j] == '1') {

                    int tmp = i * grid[0].size() + j;

                    if (j > 0 && grid[i][j - 1] == '1') {
                        ufset.Union(tmp, tmp - 1);
                    }

                    if (i > 0 && grid[i - 1][j] == '1') {
                        ufset.Union(tmp, tmp - grid[0].size());
                    }
                }

            }

        }

        int numIslands = 0;

        for (int i = 0; i < ufset.vec.size(); i++) {

            if (ufset.vec[i] < 0) {

                int x = i / grid[0].size();
                int y = i % grid[0].size();

                if (grid[x][y] == '1') {
                    numIslands++;
                }

            }

        }

        return numIslands;
    }
};

这里有一篇题解写得也很棒！https://leetcode.cn/problems/number-of-islands/solution/dao-yu-lei-wen-ti-de-tong-yong-jie-fa-dfs-bian-li-/.

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：
输入：head = [1,2]
输出：[2,1]

示例 3：
输入：head = []
输出：[]

提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

// Definition for singly-linked list.
struct ListNode {
    int val;
    ListNode* next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode* next) : val(x), next(next) {}
};
 
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr) return nullptr;
        ListNode* first = head;
        ListNode* second = head->next;

        first->next = nullptr;

        while (second != nullptr) {
            ListNode* tmp = second->next;
            // 进行逆转
            second->next = first;
            first = second;
            second = tmp;
        }

        return first;
    }
};

207. 课程表

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：
输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：
输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

提示：
$1 <= numCourses <= 10^5$
0 <= prerequisites.length <= 5000
prerequisites[i].length == 2
0 <= ai, bi < numCourses
prerequisites[i] 中的所有课程对互不相同

首先建立有向图，利用邻接链表的方法，采用vector建表。

父节点->子节点 的方式建图，正向图。（方便进行更改其它节点的入度数）

又是一道一次就过了的题目！感觉这道题目也蛮难的，有些成就感。

在这里插入图片描述

代码如下：

#include<vector>
#include<stack>

using namespace std;

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 建图的临界链表
        vector<vector<int>> courses = vector<vector<int>>(numCourses, vector<int>());
        for (int i = 0; i < prerequisites.size(); i++) {
            courses[prerequisites[i][1]].push_back(prerequisites[i][0]);
        }

        stack<int> stk;

        vector<int> inDegree(numCourses, 0);

        // 统计入度数量
        for (int i = 0; i < numCourses; i++) {
            for (int j = 0; j < courses[i].size(); j++) {
                inDegree[courses[i][j]]++;
            }
        }

        // 入度数为0的入栈
        for (int i = 0; i < inDegree.size(); i++) {
            if (inDegree[i] == 0) {
                stk.push(i);
            }
        }

        int countFinished = 0;

        // 删除已学课程
        while (!stk.empty()) {
            int curCourse = stk.top();
            stk.pop();
            countFinished++;

            // 更新 入度数量
            for (int i = 0; i < courses[curCourse].size(); i++) {
                inDegree[courses[curCourse][i]]--;
                if (inDegree[courses[curCourse][i]] == 0) {
                    stk.push(courses[curCourse][i]);
                }
            }
        }

        if (countFinished == numCourses) {
            return true;
        }
        else {
            return false;
        }
    }
};

208. 实现 Trie (前缀树)

Trie（发音类似 “try”）或者说前缀树是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。
boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
[“Trie”, “insert”, “search”, “search”, “startsWith”, “insert”, “search”]
[[], [“apple”], [“apple”], [“app”], [“app”], [“app”], [“app”]]
输出
[null, null, true, false, true, null, true]

解释
Trie trie = new Trie();
trie.insert(“apple”);
trie.search(“apple”); // 返回 True
trie.search(“app”); // 返回 False
trie.startsWith(“app”); // 返回 True
trie.insert(“app”);
trie.search(“app”); // 返回 True

提示：

1 <= word.length, prefix.length <= 2000
word 和 prefix 仅由小写英文字母组成
insert、search 和 startsWith 调用次数总计不超过 3 * 104 次

这道题目是一道设计类的题目，主要采用类似于递归的方法更新节点进行一个长树。

#include<string>
#include<vector>

using namespace std;

class Trie {
    vector<Trie*> children;
    bool isEnd;
public:
    Trie() {
        children = vector<Trie*>(26, nullptr);
        isEnd = false;
    }

    void insert(string word) {
        Trie* curNode = this;
        for (int i = 0; i < word.size(); i++) {
            int index = word[i] - 'a';

            if (curNode->children[index] == nullptr) {
                curNode->children[index] = new Trie();
            }

            curNode = curNode->children[index];
        }

        curNode->isEnd = true;
    }

    bool search(string word) {
        Trie* curNode = this;
        for (int i = 0; i < word.size(); i++) {
            if (curNode->children[word[i] - 'a'] == nullptr) {
                return false;
            }
            curNode = curNode->children[word[i] - 'a'];
        }
        // 搜索存在，表示的是必须要以这个单词为结尾
        return curNode != nullptr && curNode->isEnd;
    }

    bool startsWith(string prefix) {
        Trie* curNode = this;
        for (int i = 0; i < prefix.size(); i++) {
            if (curNode->children[prefix[i] - 'a'] == nullptr) {
                return false;
            }
            curNode = curNode->children[prefix[i] - 'a'];
        }
        return curNode != nullptr;
    }
};

Cherries Man

关注

26
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
1
评论
leetcode刷题记录10（2023-06-25）【岛屿数量(并查集) | 反转链表(注意考虑空链表边界情况) | 课程表(拓扑排序) | 实现 Trie(前缀树，一种用于自动补完等的数据结构)】

【岛屿数量(并查集) | 反转链表(注意考虑空链表边界情况) | 课程表(拓扑排序) | 实现 Trie(前缀树，一种用于自动补完等的数据结构)】
复制链接

扫一扫