feat: add No.219,228,1971

Author: BaffinLee

Diff for: 1901-2000/1971. Find if Path Exists in Graph.md

@@ -0,0 +1,101 @@
+# 1971. Find if Path Exists in Graph
+
+- Difficulty: Easy.
+- Related Topics: Depth-First Search, Breadth-First Search, Union Find, Graph.
+- Similar Questions: Valid Arrangement of Pairs, Paths in Maze That Lead to Same Room.
+
+## Problem
+
+There is a **bi-directional** graph with `n` vertices, where each vertex is labeled from `0` to `n - 1` (**inclusive**). The edges in the graph are represented as a 2D integer array `edges`, where each `edges[i] = [ui, vi]` denotes a bi-directional edge between vertex `ui` and vertex `vi`. Every vertex pair is connected by **at most one** edge, and no vertex has an edge to itself.
+
+You want to determine if there is a **valid path** that exists from vertex `source` to vertex `destination`.
+
+Given `edges` and the integers `n`, `source`, and `destination`, return `true`** if there is a **valid path** from **`source`** to **`destination`**, or **`false`** otherwise****.**
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2021/08/14/validpath-ex1.png)
+
+```
+Input: n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2
+Output: true
+Explanation: There are two paths from vertex 0 to vertex 2:
+- 0 → 1 → 2
+- 0 → 2
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2021/08/14/validpath-ex2.png)
+
+```
+Input: n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5
+Output: false
+Explanation: There is no path from vertex 0 to vertex 5.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= n <= 2 * 105`
+	
+- `0 <= edges.length <= 2 * 105`
+	
+- `edges[i].length == 2`
+	
+- `0 <= ui, vi <= n - 1`
+	
+- `ui != vi`
+	
+- `0 <= source, destination <= n - 1`
+	
+- There are no duplicate edges.
+	
+- There are no self edges.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} source
+ * @param {number} destination
+ * @return {boolean}
+ */
+var validPath = function(n, edges, source, destination) {
+    var dp = Array(n);
+    var map = Array(n).fill(0).map(() => []);
+    for (var i = 0; i < edges.length; i++) {
+        map[edges[i][0]].push(edges[i][1]);
+        map[edges[i][1]].push(edges[i][0]);
+    }
+    var dfs = function(i) {
+        if (i === destination) return true;
+        if (dp[i] !== undefined) return dp[i];
+        dp[i] = false;
+        for (var j = 0; j < map[i].length; j++) {
+            if (dfs(map[i][j])) {
+                dp[i] = true;
+                break;
+            }
+        }
+        return dp[i];
+    };
+    return dfs(source);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

Diff for: 201-300/219. Contains Duplicate II.md

@@ -0,0 +1,71 @@
+# 219. Contains Duplicate II
+
+- Difficulty: Easy.
+- Related Topics: Array, Hash Table, Sliding Window.
+- Similar Questions: Contains Duplicate, Contains Duplicate III.
+
+## Problem
+
+Given an integer array `nums` and an integer `k`, return `true` **if there are two **distinct indices** **`i`** and **`j`** in the array such that **`nums[i] == nums[j]`** and **`abs(i - j) <= k`.
+
+ 
+Example 1:
+
+```
+Input: nums = [1,2,3,1], k = 3
+Output: true
+```
+
+Example 2:
+
+```
+Input: nums = [1,0,1,1], k = 1
+Output: true
+```
+
+Example 3:
+
+```
+Input: nums = [1,2,3,1,2,3], k = 2
+Output: false
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= nums.length <= 105`
+	
+- `-109 <= nums[i] <= 109`
+	
+- `0 <= k <= 105`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+var containsNearbyDuplicate = function(nums, k) {
+    var map = {};
+    for (var i = 0; i < nums.length; i++) {
+        if (map[nums[i]] !== undefined && i - map[nums[i]] <= k) return true;
+        map[nums[i]] = i;
+    }
+    return false;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

Diff for: 201-300/228. Summary Ranges.md

@@ -0,0 +1,87 @@
+# 228. Summary Ranges
+
+- Difficulty: Easy.
+- Related Topics: Array.
+- Similar Questions: Missing Ranges, Data Stream as Disjoint Intervals, Find Maximal Uncovered Ranges.
+
+## Problem
+
+You are given a **sorted unique** integer array `nums`.
+
+A **range** `[a,b]` is the set of all integers from `a` to `b` (inclusive).
+
+Return **the **smallest sorted** list of ranges that **cover all the numbers in the array exactly****. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`.
+
+Each range `[a,b]` in the list should be output as:
+
+
+	
+- `"a->b"` if `a != b`
+	
+- `"a"` if `a == b`
+
+
+ 
+Example 1:
+
+```
+Input: nums = [0,1,2,4,5,7]
+Output: ["0->2","4->5","7"]
+Explanation: The ranges are:
+[0,2] --> "0->2"
+[4,5] --> "4->5"
+[7,7] --> "7"
+```
+
+Example 2:
+
+```
+Input: nums = [0,2,3,4,6,8,9]
+Output: ["0","2->4","6","8->9"]
+Explanation: The ranges are:
+[0,0] --> "0"
+[2,4] --> "2->4"
+[6,6] --> "6"
+[8,9] --> "8->9"
+```
+
+ 
+**Constraints:**
+
+
+	
+- `0 <= nums.length <= 20`
+	
+- `-231 <= nums[i] <= 231 - 1`
+	
+- All the values of `nums` are **unique**.
+	
+- `nums` is sorted in ascending order.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {string[]}
+ */
+var summaryRanges = function(nums) {
+    var res = [];
+    for (var i = 0; i < nums.length; i++) {
+        if (i === 0 || nums[i] !== nums[i - 1] + 1) res.push(`${nums[i]}`);
+        else if (i === nums.length - 1 || nums[i] !== nums[i + 1] - 1) res[res.length - 1] += `->${nums[i]}`;
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).