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
<
=
n
u
m
C
o
u
r
s
e
s
<
=
1
0
5
1 <= numCourses <= 10^5
1<=numCourses<=105
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;
}
};