> q;
+ long long ans = 0, s = 0;
+ for (auto& [a, b] : nums) {
+ s += b;
+ q.push(b);
+ if (q.size() == k) {
+ ans = max(ans, s * -a);
+ s -= q.top();
+ q.pop();
+ }
+ }
+ return ans;
+ }
+};
+```
+
+#### Go
+
+```go
+func maxScore(nums1 []int, nums2 []int, k int) int64 {
+ type pair struct{ a, b int }
+ nums := []pair{}
+ for i, a := range nums1 {
+ b := nums2[i]
+ nums = append(nums, pair{a, b})
+ }
+ sort.Slice(nums, func(i, j int) bool { return nums[i].b > nums[j].b })
+ q := hp{}
+ var ans, s int
+ for _, e := range nums {
+ a, b := e.a, e.b
+ s += a
+ heap.Push(&q, a)
+ if q.Len() == k {
+ ans = max(ans, s*b)
+ s -= heap.Pop(&q).(int)
+ }
+ }
+ return int64(ans)
+}
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
+func (h *hp) Push(v any) { h.IntSlice = append(h.IntSlice, v.(int)) }
+func (h *hp) Pop() any {
+ a := h.IntSlice
+ v := a[len(a)-1]
+ h.IntSlice = a[:len(a)-1]
+ return v
+}
+```
+
+
diff --git a/Solution/374. Guess Number Higher or Lower/374. Guess Number Higher or Lower.py b/Solution/374. Guess Number Higher or Lower/374. Guess Number Higher or Lower.py
new file mode 100644
index 0000000..934a98d
--- /dev/null
+++ b/Solution/374. Guess Number Higher or Lower/374. Guess Number Higher or Lower.py
@@ -0,0 +1,11 @@
+# The guess API is already defined for you.
+# @param num, your guess
+# @return -1 if num is higher than the picked number
+# 1 if num is lower than the picked number
+# otherwise return 0
+# def guess(num: int) -> int:
+
+
+class Solution:
+ def guessNumber(self, n: int) -> int:
+ return bisect.bisect(range(1, n + 1), 0, key=lambda x: -guess(x))
\ No newline at end of file
diff --git a/Solution/374. Guess Number Higher or Lower/readme.md b/Solution/374. Guess Number Higher or Lower/readme.md
new file mode 100644
index 0000000..3ad09c9
--- /dev/null
+++ b/Solution/374. Guess Number Higher or Lower/readme.md
@@ -0,0 +1,288 @@
+
+# [374. Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower)
+---
+- **comments**: true
+- **difficulty**: Easy
+- **edit_url**: https://github.com/doocs/leetcode/edit/main/solution/0300-0399/0374.Guess%20Number%20Higher%20or%20Lower/README_EN.md
+- **tags**:
+ - Binary Search
+ - Interactive
+---
+
+
+## Description
+
+
+
+We are playing the Guess Game. The game is as follows:
+
+I pick a number from 1 to n. You have to guess which number I picked.
+
+Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.
+
+You call a pre-defined API int guess(int num), which returns three possible results:
+
+
+ -1: Your guess is higher than the number I picked (i.e. num > pick).1: Your guess is lower than the number I picked (i.e. num < pick).0: your guess is equal to the number I picked (i.e. num == pick).
+
+Return the number that I picked.
+
+
+Example 1:
+
+
+Input: n = 10, pick = 6
+Output: 6
+
+
+Example 2:
+
+
+Input: n = 1, pick = 1
+Output: 1
+
+
+Example 3:
+
+
+Input: n = 2, pick = 1
+Output: 1
+
+
+
+Constraints:
+
+
+ 1 <= n <= 231 - 11 <= pick <= n
+
+
+
+## Solutions
+
+
+
+### Solution 1: Binary Search
+
+We perform a binary search in the interval $[1,..n]$, and find the first number that satisfies `guess(x) <= 0`, which is the answer.
+
+The time complexity is $O(\log n)$, where $n$ is the upper limit given in the problem. The space complexity is $O(1)$.
+
+
+
+#### Python3
+
+```python
+# The guess API is already defined for you.
+# @param num, your guess
+# @return -1 if num is higher than the picked number
+# 1 if num is lower than the picked number
+# otherwise return 0
+# def guess(num: int) -> int:
+
+
+class Solution:
+ def guessNumber(self, n: int) -> int:
+ left, right = 1, n
+ while left < right:
+ mid = (left + right) // 2
+ if guess(mid) == 0:
+ return mid
+ elif guess(mid) == -1:
+ right = mid - 1
+ else:
+ left = mid + 1
+ return left
+```
+
+#### Java
+
+```java
+/**
+ * Forward declaration of guess API.
+ * @param num your guess
+ * @return -1 if num is lower than the guess number
+ * 1 if num is higher than the guess number
+ * otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution extends GuessGame {
+ public int guessNumber(int n) {
+ int left = 1, right = n;
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (guess(mid) == 0) {
+ return mid;
+ } else if (guess(mid) == -1) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+ }
+}
+```
+
+#### C++
+
+```cpp
+/**
+ * Forward declaration of guess API.
+ * @param num your guess
+ * @return -1 if num is lower than the guess number
+ * 1 if num is higher than the guess number
+ * otherwise return 0
+ * int guess(int num);
+ */
+
+class Solution {
+public:
+ int guessNumber(int n) {
+ int left = 1, right = n;
+ while (left < right) {
+ int mid = left + ((right - left) >> 1);
+ if (guess(mid) == 0) {
+ return mid;
+ } else if (guess(mid) == -1) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+ }
+};
+```
+
+#### Go
+
+```go
+/**
+ * Forward declaration of guess API.
+ * @param num your guess
+ * @return -1 if num is higher than the picked number
+ * 1 if num is lower than the picked number
+ * otherwise return 0
+ * func guess(num int) int;
+ */
+
+func guessNumber(n int) int {
+ left, right := 1, n
+ for left < right {
+ mid := (left + right) / 2
+ if guess(mid) == 0 {
+ return mid
+ } else if guess(mid) == -1 {
+ right = mid - 1
+ } else {
+ left = mid + 1
+ }
+ }
+ return left
+}
+```
+
+#### TypeScript
+
+```ts
+/**
+ * Forward declaration of guess API.
+ * @param {number} num your guess
+ * @return -1 if num is lower than the guess number
+ * 1 if num is higher than the guess number
+ * otherwise return 0
+ * var guess = function(num) {}
+ */
+
+function guessNumber(n: number): number {
+ let left = 1, right = n;
+ while (left < right) {
+ const mid = (left + right) >>> 1;
+ if (guess(mid) == 0) {
+ return mid;
+ } else if (guess(mid) == -1) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+}
+```
+
+#### Rust
+
+```rust
+/**
+ * Forward declaration of guess API.
+ * @param num your guess
+ * @return -1 if num is lower than the guess number
+ * 1 if num is higher than the guess number
+ * otherwise return 0
+ * unsafe fn guess(num: i32) -> i32 {}
+ */
+
+impl Solution {
+ unsafe fn guessNumber(n: i32) -> i32 {
+ let mut left = 1;
+ let mut right = n;
+ loop {
+ let mid = left + (right - left) / 2;
+ match guess(mid) {
+ -1 => {
+ right = mid - 1;
+ }
+ 1 => {
+ left = mid + 1;
+ }
+ _ => {
+ break mid;
+ }
+ }
+ }
+ }
+}
+```
+
+#### C#
+
+```cs
+/**
+ * Forward declaration of guess API.
+ * @param num your guess
+ * @return -1 if num is higher than the picked number
+ * 1 if num is lower than the picked number
+ * otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution : GuessGame {
+ public int GuessNumber(int n) {
+ int left = 1, right = n;
+ while (left < right) {
+ int mid = left + ((right - left) >> 1);
+ if (guess(mid) == 0) {
+ return mid;
+ } else if (guess(mid) == -1) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+ }
+}
+```
+
+
+
+
+
+
+```
\ No newline at end of file
diff --git a/Solution/399. Evaluate Division/399. Evaluate Division.py b/Solution/399. Evaluate Division/399. Evaluate Division.py
new file mode 100644
index 0000000..d980e65
--- /dev/null
+++ b/Solution/399. Evaluate Division/399. Evaluate Division.py
@@ -0,0 +1,26 @@
+class Solution:
+ def calcEquation(
+ self, equations: List[List[str]], values: List[float], queries: List[List[str]]
+ ) -> List[float]:
+ def find(x):
+ if p[x] != x:
+ origin = p[x]
+ p[x] = find(p[x])
+ w[x] *= w[origin]
+ return p[x]
+
+ w = defaultdict(lambda: 1)
+ p = defaultdict()
+ for a, b in equations:
+ p[a], p[b] = a, b
+ for i, v in enumerate(values):
+ a, b = equations[i]
+ pa, pb = find(a), find(b)
+ if pa == pb:
+ continue
+ p[pa] = pb
+ w[pa] = w[b] * v / w[a]
+ return [
+ -1 if c not in p or d not in p or find(c) != find(d) else w[c] / w[d]
+ for c, d in queries
+ ]
\ No newline at end of file
diff --git a/Solution/399. Evaluate Division/readme.md b/Solution/399. Evaluate Division/readme.md
new file mode 100644
index 0000000..e6c6a05
--- /dev/null
+++ b/Solution/399. Evaluate Division/readme.md
@@ -0,0 +1,309 @@
+
+
+
+# [399. Evaluate Division](https://leetcode.com/problems/evaluate-division)
+
+---
+- **comments**: true
+- **difficulty**: Medium
+- **edit_url**: https://github.com/doocs/leetcode/edit/main/solution/0300-0399/0399.Evaluate%20Division/README_EN.md
+- **tags**:
+ - Depth-First Search
+ - Breadth-First Search
+ - Union Find
+ - Graph
+ - Array
+ - String
+ - Shortest Path
+---
+
+## Description
+
+
+
+You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable.
+
+You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?.
+
+Return the answers to all queries. If a single answer cannot be determined, return -1.0.
+
+Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
+
+Note: The variables that do not occur in the list of equations are undefined, so the answer cannot be determined for them.
+
+
+Example 1:
+
+
+Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
+Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]
+Explanation:
+Given: a / b = 2.0, b / c = 3.0
+queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
+return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
+note: x is undefined => -1.0
+
+Example 2:
+
+
+Input: equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
+Output: [3.75000,0.40000,5.00000,0.20000]
+
+
+Example 3:
+
+
+Input: equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
+Output: [0.50000,2.00000,-1.00000,-1.00000]
+
+
+
+Constraints:
+
+
+ 1 <= equations.length <= 20equations[i].length == 21 <= Ai.length, Bi.length <= 5values.length == equations.length0.0 < values[i] <= 20.01 <= queries.length <= 20queries[i].length == 21 <= Cj.length, Dj.length <= 5Ai, Bi, Cj, Dj consist of lower case English letters and digits.
+
+
+
+## Solutions
+
+
+
+### Solution 1
+
+
+
+#### Python3
+
+```python
+class Solution:
+ def calcEquation(
+ self, equations: List[List[str]], values: List[float], queries: List[List[str]]
+ ) -> List[float]:
+ def find(x):
+ if p[x] != x:
+ origin = p[x]
+ p[x] = find(p[x])
+ w[x] *= w[origin]
+ return p[x]
+
+ w = defaultdict(lambda: 1)
+ p = defaultdict()
+ for a, b in equations:
+ p[a], p[b] = a, b
+ for i, v in enumerate(values):
+ a, b = equations[i]
+ pa, pb = find(a), find(b)
+ if pa == pb:
+ continue
+ p[pa] = pb
+ w[pa] = w[b] * v / w[a]
+ return [
+ -1 if c not in p or d not in p or find(c) != find(d) else w[c] / w[d]
+ for c, d in queries
+ ]
+```
+
+#### Java
+
+```java
+class Solution {
+ private Map p;
+ private Map w;
+
+ public double[] calcEquation(
+ List> equations, double[] values, List> queries) {
+ int n = equations.size();
+ p = new HashMap<>();
+ w = new HashMap<>();
+ for (List e : equations) {
+ p.put(e.get(0), e.get(0));
+ p.put(e.get(1), e.get(1));
+ w.put(e.get(0), 1.0);
+ w.put(e.get(1), 1.0);
+ }
+ for (int i = 0; i < n; ++i) {
+ List e = equations.get(i);
+ String a = e.get(0), b = e.get(1);
+ String pa = find(a), pb = find(b);
+ if (Objects.equals(pa, pb)) {
+ continue;
+ }
+ p.put(pa, pb);
+ w.put(pa, w.get(b) * values[i] / w.get(a));
+ }
+ int m = queries.size();
+ double[] ans = new double[m];
+ for (int i = 0; i < m; ++i) {
+ String c = queries.get(i).get(0), d = queries.get(i).get(1);
+ ans[i] = !p.containsKey(c) || !p.containsKey(d) || !Objects.equals(find(c), find(d))
+ ? -1.0
+ : w.get(c) / w.get(d);
+ }
+ return ans;
+ }
+
+ private String find(String x) {
+ if (!Objects.equals(p.get(x), x)) {
+ String origin = p.get(x);
+ p.put(x, find(p.get(x)));
+ w.put(x, w.get(x) * w.get(origin));
+ }
+ return p.get(x);
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ unordered_map p;
+ unordered_map w;
+
+ vector calcEquation(vector>& equations, vector& values, vector>& queries) {
+ int n = equations.size();
+ for (auto e : equations) {
+ p[e[0]] = e[0];
+ p[e[1]] = e[1];
+ w[e[0]] = 1.0;
+ w[e[1]] = 1.0;
+ }
+ for (int i = 0; i < n; ++i) {
+ vector e = equations[i];
+ string a = e[0], b = e[1];
+ string pa = find(a), pb = find(b);
+ if (pa == pb) continue;
+ p[pa] = pb;
+ w[pa] = w[b] * values[i] / w[a];
+ }
+ int m = queries.size();
+ vector ans(m);
+ for (int i = 0; i < m; ++i) {
+ string c = queries[i][0], d = queries[i][1];
+ ans[i] = p.find(c) == p.end() || p.find(d) == p.end()
+
+ || find(c) != find(d) ? -1.0 : w[c] / w[d];
+ }
+ return ans;
+ }
+
+private:
+ string find(string x) {
+ if (p[x] != x) {
+ string origin = p[x];
+ p[x] = find(p[x]);
+ w[x] *= w[origin];
+ }
+ return p[x];
+ }
+};
+```
+
+#### Go
+
+```go
+func calcEquation(equations [][]string, values []float64, queries [][]string) []float64 {
+ p := make(map[string]string)
+ w := make(map[string]float64)
+ for i := 0; i < len(equations); i++ {
+ a, b := equations[i][0], equations[i][1]
+ p[a], p[b] = a, b
+ w[a], w[b] = 1.0, 1.0
+ }
+ for i, v := range values {
+ a, b := equations[i][0], equations[i][1]
+ pa, pb := find(a, p, w), find(b, p, w)
+ if pa == pb {
+ continue
+ }
+ p[pa] = pb
+ w[pa] = w[b] * v / w[a]
+ }
+
+ res := make([]float64, len(queries))
+ for i, q := range queries {
+ c, d := q[0], q[1]
+ if _, ok1 := p[c]; !ok1 || _, ok2 := p[d]; !ok2 || find(c, p, w) != find(d, p, w) {
+ res[i] = -1.0
+ } else {
+ res[i] = w[c] / w[d]
+ }
+ }
+ return res
+}
+
+func find(x string, p map[string]string, w map[string]float64) string {
+ if p[x] != x {
+ origin := p[x]
+ p[x] = find(p[x], p, w)
+ w[x] *= w[origin]
+ }
+ return p[x]
+}
+```
+
+#### TypeScript
+
+```typescript
+function calcEquation(equations: string[][], values: number[], queries: string[][]): number[] {
+ const p: { [key: string]: string } = {};
+ const w: { [key: string]: number } = {};
+ equations.forEach((eq, i) => {
+ const [a, b] = eq;
+ p[a] = a;
+ p[b] = b;
+ w[a] = 1;
+ w[b] = 1;
+ });
+
+ equations.forEach((eq, i) => {
+ const [a, b] = eq;
+ const pa = find(a, p, w);
+ const pb = find(b, p, w);
+ if (pa === pb) return;
+ p[pa] = pb;
+ w[pa] = w[b] * values[i] / w[a];
+ });
+
+ return queries.map(([c, d]) => {
+ if (!p[c] || !p[d] || find(c, p, w) !== find(d, p, w)) {
+ return -1;
+ }
+ return w[c] / w[d];
+ });
+}
+
+function find(x: string, p: { [key: string]: string }, w: { [key: string]: number }): string {
+ if (p[x] !== x) {
+ const origin = p[x];
+ p[x] = find(p[x], p, w);
+ w[x] *= w[origin];
+ }
+ return p[x];
+}
+```
+
+
+
+### Solution 2
+
+
+
+#### Python3
+
+```python
+# Alternative Solution using DFS to traverse the graph
+```
+
+
diff --git a/Solution/547. Number of Provinces/547. Number of Provinces.py b/Solution/547. Number of Provinces/547. Number of Provinces.py
new file mode 100644
index 0000000..f680742
--- /dev/null
+++ b/Solution/547. Number of Provinces/547. Number of Provinces.py
@@ -0,0 +1,16 @@
+class Solution:
+ def findCircleNum(self, isConnected: List[List[int]]) -> int:
+ def dfs(i: int):
+ vis[i] = True
+ for j, x in enumerate(isConnected[i]):
+ if not vis[j] and x:
+ dfs(j)
+
+ n = len(isConnected)
+ vis = [False] * n
+ ans = 0
+ for i in range(n):
+ if not vis[i]:
+ dfs(i)
+ ans += 1
+ return ans
\ No newline at end of file
diff --git a/Solution/547. Number of Provinces/readme.md b/Solution/547. Number of Provinces/readme.md
new file mode 100644
index 0000000..f10581f
--- /dev/null
+++ b/Solution/547. Number of Provinces/readme.md
@@ -0,0 +1,372 @@
+# 547. Number of Provinces
+- **difficulty**: Medium
+- **related**: []
+- **tags**:
+ - **Depth**-First Search
+ - **Breadth**-First Search
+ - **Union Find**
+ - **Graph**
+---
+
+## Description
+
+There are `n` cities. Some of them are connected, while some are not. If city `a` is connected directly with city `b`, and city `b` is connected directly with city `c`, then city `a` is connected indirectly with city `c`.
+
+A **province** is a group of directly or indirectly connected cities and no other cities outside of the group.
+
+You are given an `n x n` matrix `isConnected` where `isConnected[i][j] = 1` if the `i-th` city and the `j-th` city are directly connected, and `isConnected[i][j] = 0` otherwise.
+
+Return *the total number of **provinces***.
+
+## Examples
+
+**Example 1:**
+
+```
+Input: isConnected = [[1,1,0],[1,1,0],[0,0,1]]
+Output: 2
+```
+
+**Example 2:**
+
+```
+Input: isConnected = [[1,0,0],[0,1,0],[0,0,1]]
+Output: 3
+```
+
+## Constraints
+
+- `1 <= n <= 200`
+- `n == isConnected.length`
+- `n == isConnected[i].length`
+- `isConnected[i][j]` is `1` or `0`.
+- `isConnected[i][i] == 1`
+- `isConnected[i][j] == isConnected[j][i]`
+
+## Solutions
+
+### Solution 1: DFS
+
+We maintain a visited array and perform DFS from each unvisited node, marking all reachable nodes as visited. Each DFS traversal corresponds to a new province.
+
+**Time Complexity:** O(nΒ²)
+**Space Complexity:** O(n)
+
+#### Python
+
+```python
+class Solution:
+ def findCircleNum(self, isConnected: List[List[int]]) -> int:
+ def dfs(i: int):
+ vis[i] = True
+ for j, x in enumerate(isConnected[i]):
+ if not vis[j] and x:
+ dfs(j)
+
+ n = len(isConnected)
+ vis = [False] * n
+ ans = 0
+ for i in range(n):
+ if not vis[i]:
+ dfs(i)
+ ans += 1
+ return ans
+```
+
+#### Java
+
+```java
+class Solution {
+ private int[][] g;
+ private boolean[] vis;
+
+ public int findCircleNum(int[][] isConnected) {
+ g = isConnected;
+ int n = g.length;
+ vis = new boolean[n];
+ int ans = 0;
+ for (int i = 0; i < n; ++i) {
+ if (!vis[i]) {
+ dfs(i);
+ ++ans;
+ }
+ }
+ return ans;
+ }
+
+ private void dfs(int i) {
+ vis[i] = true;
+ for (int j = 0; j < g.length; ++j) {
+ if (!vis[j] && g[i][j] == 1) {
+ dfs(j);
+ }
+ }
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ int findCircleNum(vector>& isConnected) {
+ int n = isConnected.size();
+ int ans = 0;
+ vector vis(n, false);
+ function dfs = [&](int i) {
+ vis[i] = true;
+ for (int j = 0; j < n; ++j) {
+ if (!vis[j] && isConnected[i][j]) {
+ dfs(j);
+ }
+ }
+ };
+ for (int i = 0; i < n; ++i) {
+ if (!vis[i]) {
+ dfs(i);
+ ++ans;
+ }
+ }
+ return ans;
+ }
+};
+```
+
+#### Go
+
+```go
+func findCircleNum(isConnected [][]int) int {
+ n := len(isConnected)
+ vis := make([]bool, n)
+ var dfs func(int)
+ dfs = func(i int) {
+ vis[i] = true
+ for j, x := range isConnected[i] {
+ if !vis[j] && x == 1 {
+ dfs(j)
+ }
+ }
+ }
+ ans := 0
+ for i := range vis {
+ if !vis[i] {
+ ans++
+ dfs(i)
+ }
+ }
+ return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function findCircleNum(isConnected: number[][]): number {
+ const n = isConnected.length;
+ const vis = Array(n).fill(false);
+ const dfs = (i: number) => {
+ vis[i] = true;
+ for (let j = 0; j < n; ++j) {
+ if (!vis[j] && isConnected[i][j]) {
+ dfs(j);
+ }
+ }
+ };
+ let ans = 0;
+ for (let i = 0; i < n; ++i) {
+ if (!vis[i]) {
+ dfs(i);
+ ++ans;
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ fn dfs(is_connected: &Vec>, vis: &mut Vec, i: usize) {
+ vis[i] = true;
+ for j in 0..is_connected.len() {
+ if !vis[j] && is_connected[i][j] == 1 {
+ Self::dfs(is_connected, vis, j);
+ }
+ }
+ }
+
+ pub fn find_circle_num(is_connected: Vec>) -> i32 {
+ let n = is_connected.len();
+ let mut vis = vec![false; n];
+ let mut res = 0;
+ for i in 0..n {
+ if !vis[i] {
+ res += 1;
+ Self::dfs(&is_connected, &mut vis, i);
+ }
+ }
+ res
+ }
+}
+```
+
+---
+
+### Solution 2: Union-Find
+
+Use Union-Find to group connected cities. Initially each city is its own parent. Merge cities with direct connections and count the number of distinct roots.
+
+**Time Complexity:** O(nΒ² * Ξ±(n))
+**Space Complexity:** O(n)
+
+#### Python
+
+```python
+class Solution:
+ def findCircleNum(self, isConnected: List[List[int]]) -> int:
+ def find(x):
+ if p[x] != x:
+ p[x] = find(p[x])
+ return p[x]
+
+ n = len(isConnected)
+ p = list(range(n))
+ ans = n
+ for i in range(n):
+ for j in range(i + 1, n):
+ if isConnected[i][j]:
+ pa, pb = find(i), find(j)
+ if pa != pb:
+ p[pa] = pb
+ ans -= 1
+ return ans
+```
+
+#### Java
+
+```java
+class Solution {
+ private int[] p;
+
+ public int findCircleNum(int[][] isConnected) {
+ int n = isConnected.length;
+ p = new int[n];
+ for (int i = 0; i < n; ++i) {
+ p[i] = i;
+ }
+ int ans = n;
+ for (int i = 0; i < n; ++i) {
+ for (int j = i + 1; j < n; ++j) {
+ if (isConnected[i][j] == 1) {
+ int pa = find(i), pb = find(j);
+ if (pa != pb) {
+ p[pa] = pb;
+ --ans;
+ }
+ }
+ }
+ }
+ return ans;
+ }
+
+ private int find(int x) {
+ if (p[x] != x) {
+ p[x] = find(p[x]);
+ }
+ return p[x];
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ int findCircleNum(vector>& isConnected) {
+ int n = isConnected.size();
+ vector p(n);
+ iota(p.begin(), p.end(), 0);
+ function find = [&](int x) {
+ return p[x] == x ? x : p[x] = find(p[x]);
+ };
+ int ans = n;
+ for (int i = 0; i < n; ++i) {
+ for (int j = i + 1; j < n; ++j) {
+ if (isConnected[i][j]) {
+ int pa = find(i), pb = find(j);
+ if (pa != pb) {
+ p[pa] = pb;
+ --ans;
+ }
+ }
+ }
+ }
+ return ans;
+ }
+};
+```
+
+#### Go
+
+```go
+func findCircleNum(isConnected [][]int) int {
+ n := len(isConnected)
+ p := make([]int, n)
+ for i := range p {
+ p[i] = i
+ }
+ var find func(int) int
+ find = func(x int) int {
+ if p[x] != x {
+ p[x] = find(p[x])
+ }
+ return p[x]
+ }
+ ans := n
+ for i := 0; i < n; i++ {
+ for j := i + 1; j < n; j++ {
+ if isConnected[i][j] == 1 {
+ pa, pb := find(i), find(j)
+ if pa != pb {
+ p[pa] = pb
+ ans--
+ }
+ }
+ }
+ }
+ return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function findCircleNum(isConnected: number[][]): number {
+ const n = isConnected.length;
+ const p: number[] = Array.from({ length: n }, (_, i) => i);
+ const find = (x: number): number => {
+ if (p[x] !== x) {
+ p[x] = find(p[x]);
+ }
+ return p[x];
+ };
+ let ans = n;
+ for (let i = 0; i < n; ++i) {
+ for (let j = i + 1; j < n; ++j) {
+ if (isConnected[i][j]) {
+ const pa = find(i), pb = find(j);
+ if (pa !== pb) {
+ p[pa] = pb;
+ --ans;
+ }
+ }
+ }
+ }
+ return ans;
+}
+```
+
+---
diff --git a/Solution/994. Rotting Oranges/994. Rotting Oranges.py b/Solution/994. Rotting Oranges/994. Rotting Oranges.py
new file mode 100644
index 0000000..ba3a766
--- /dev/null
+++ b/Solution/994. Rotting Oranges/994. Rotting Oranges.py
@@ -0,0 +1,26 @@
+class Solution:
+ def orangesRotting(self, grid: List[List[int]]) -> int:
+ m, n = len(grid), len(grid[0])
+ cnt = 0
+ q = deque()
+ for i, row in enumerate(grid):
+ for j, x in enumerate(row):
+ if x == 2:
+ q.append((i, j))
+ elif x == 1:
+ cnt += 1
+ ans = 0
+ dirs = (-1, 0, 1, 0, -1)
+ while q and cnt:
+ ans += 1
+ for _ in range(len(q)):
+ i, j = q.popleft()
+ for a, b in pairwise(dirs):
+ x, y = i + a, j + b
+ if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+ grid[x][y] = 2
+ q.append((x, y))
+ cnt -= 1
+ if cnt == 0:
+ return ans
+ return -1 if cnt else 0
\ No newline at end of file
diff --git a/Solution/994. Rotting Oranges/readme.md b/Solution/994. Rotting Oranges/readme.md
new file mode 100644
index 0000000..c1a7785
--- /dev/null
+++ b/Solution/994. Rotting Oranges/readme.md
@@ -0,0 +1,346 @@
+
+
+
+
+
+# [994. Rotting Oranges](https://leetcode.com/problems/rotting-oranges)
+---
+- **comments**: true
+- **difficulty**: Medium
+- **edit_url**: https://github.com/doocs/leetcode/edit/main/solution/0900-0999/0994.Rotting%20Oranges/README_EN.md
+- **tags**:
+ - Breadth-First Search
+ - Array
+ - Matrix
+---
+
+## Description
+
+You are given an `m x n` grid where each cell can have one of three values:
+
+- `0` representing an empty cell,
+- `1` representing a fresh orange, or
+- `2` representing a rotten orange.
+
+Every minute, any fresh orange that is **4-directionally adjacent** to a rotten orange becomes rotten.
+
+Return *the minimum number of minutes that must elapse until no cell has a fresh orange*. If this is impossible, return `-1`.
+
+**Example 1:**
+
+
+
+```
+Input: grid = [[2,1,1],[1,1,0],[0,1,1]]
+Output: 4
+```
+
+**Example 2:**
+
+```
+Input: grid = [[2,1,1],[0,1,1],[1,0,1]]
+Output: -1
+Explanation: The orange in the bottom left corner (row 2, column 0) is never rotten.
+```
+
+**Example 3:**
+
+```
+Input: grid = [[0,2]]
+Output: 0
+Explanation: There are no fresh oranges to begin with.
+```
+
+**Constraints:**
+
+- `m == grid.length`
+- `n == grid[i].length`
+- `1 <= m, n <= 10`
+- `grid[i][j]` is `0`, `1`, or `2`.
+
+
+
+## Solutions
+
+### Solution 1: BFS
+
+We start by iterating over the grid to count the number of fresh oranges and collect all rotten orange positions into a queue. Then we simulate the process of rotting using Breadth-First Search (BFS). At each minute (each level in BFS), rotten oranges spread to adjacent fresh oranges.
+
+If at the end, fresh oranges remain, return `-1`. Otherwise, return the total minutes elapsed.
+
+Time complexity: `O(m * n)`
+Space complexity: `O(m * n)`
+
+
+
+### **Python3**
+
+```python
+from collections import deque
+from itertools import pairwise
+
+class Solution:
+ def orangesRotting(self, grid: List[List[int]]) -> int:
+ m, n = len(grid), len(grid[0])
+ cnt = 0
+ q = deque()
+ for i in range(m):
+ for j in range(n):
+ if grid[i][j] == 2:
+ q.append((i, j))
+ elif grid[i][j] == 1:
+ cnt += 1
+ ans = 0
+ dirs = (-1, 0, 1, 0, -1)
+ while q and cnt:
+ ans += 1
+ for _ in range(len(q)):
+ i, j = q.popleft()
+ for a, b in pairwise(dirs):
+ x, y = i + a, j + b
+ if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+ grid[x][y] = 2
+ q.append((x, y))
+ cnt -= 1
+ if cnt == 0:
+ return ans
+ return -1 if cnt else 0
+```
+
+### **Java**
+
+```java
+class Solution {
+ public int orangesRotting(int[][] grid) {
+ int m = grid.length, n = grid[0].length;
+ Deque q = new ArrayDeque<>();
+ int cnt = 0;
+ for (int i = 0; i < m; ++i) {
+ for (int j = 0; j < n; ++j) {
+ if (grid[i][j] == 1) {
+ ++cnt;
+ } else if (grid[i][j] == 2) {
+ q.offer(new int[] {i, j});
+ }
+ }
+ }
+ final int[] dirs = {-1, 0, 1, 0, -1};
+ for (int ans = 1; !q.isEmpty() && cnt > 0; ++ans) {
+ for (int k = q.size(); k > 0; --k) {
+ var p = q.poll();
+ for (int d = 0; d < 4; ++d) {
+ int x = p[0] + dirs[d], y = p[1] + dirs[d + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+ grid[x][y] = 2;
+ q.offer(new int[] {x, y});
+ if (--cnt == 0) {
+ return ans;
+ }
+ }
+ }
+ }
+ }
+ return cnt > 0 ? -1 : 0;
+ }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+ int orangesRotting(vector>& grid) {
+ int m = grid.size(), n = grid[0].size();
+ queue> q;
+ int cnt = 0;
+ for (int i = 0; i < m; ++i) {
+ for (int j = 0; j < n; ++j) {
+ if (grid[i][j] == 1) {
+ ++cnt;
+ } else if (grid[i][j] == 2) {
+ q.emplace(i, j);
+ }
+ }
+ }
+ const int dirs[5] = {-1, 0, 1, 0, -1};
+ for (int ans = 1; !q.empty() && cnt > 0; ++ans) {
+ for (int k = q.size(); k > 0; --k) {
+ auto [i, j] = q.front();
+ q.pop();
+ for (int d = 0; d < 4; ++d) {
+ int x = i + dirs[d], y = j + dirs[d + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+ grid[x][y] = 2;
+ q.emplace(x, y);
+ if (--cnt == 0) return ans;
+ }
+ }
+ }
+ }
+ return cnt > 0 ? -1 : 0;
+ }
+};
+```
+
+### **Go**
+
+```go
+func orangesRotting(grid [][]int) int {
+ m, n := len(grid), len(grid[0])
+ q := [][2]int{}
+ cnt := 0
+ for i := range grid {
+ for j := range grid[0] {
+ if grid[i][j] == 2 {
+ q = append(q, [2]int{i, j})
+ } else if grid[i][j] == 1 {
+ cnt++
+ }
+ }
+ }
+ dirs := [5]int{-1, 0, 1, 0, -1}
+ for ans := 1; len(q) > 0 && cnt > 0; ans++ {
+ for k := len(q); k > 0; k-- {
+ p := q[0]
+ q = q[1:]
+ for d := 0; d < 4; d++ {
+ x, y := p[0]+dirs[d], p[1]+dirs[d+1]
+ if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 {
+ grid[x][y] = 2
+ q = append(q, [2]int{x, y})
+ cnt--
+ if cnt == 0 {
+ return ans
+ }
+ }
+ }
+ }
+ }
+ if cnt > 0 {
+ return -1
+ }
+ return 0
+}
+```
+
+### **TypeScript**
+
+```ts
+function orangesRotting(grid: number[][]): number {
+ const m = grid.length, n = grid[0].length;
+ const q: number[][] = [];
+ let cnt = 0;
+ for (let i = 0; i < m; ++i) {
+ for (let j = 0; j < n; ++j) {
+ if (grid[i][j] === 2) q.push([i, j]);
+ else if (grid[i][j] === 1) cnt++;
+ }
+ }
+ const dirs = [-1, 0, 1, 0, -1];
+ for (let ans = 1; q.length && cnt > 0; ++ans) {
+ const t: number[][] = [];
+ for (const [i, j] of q) {
+ for (let d = 0; d < 4; ++d) {
+ const x = i + dirs[d], y = j + dirs[d + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] === 1) {
+ grid[x][y] = 2;
+ t.push([x, y]);
+ cnt--;
+ if (cnt === 0) return ans;
+ }
+ }
+ }
+ q.splice(0, q.length, ...t);
+ }
+ return cnt > 0 ? -1 : 0;
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::VecDeque;
+
+impl Solution {
+ pub fn oranges_rotting(mut grid: Vec>) -> i32 {
+ let m = grid.len();
+ let n = grid[0].len();
+ let mut q = VecDeque::new();
+ let mut cnt = 0;
+
+ for i in 0..m {
+ for j in 0..n {
+ match grid[i][j] {
+ 1 => cnt += 1,
+ 2 => q.push_back((i, j)),
+ _ => (),
+ }
+ }
+ }
+
+ let dirs = [-1, 0, 1, 0, -1];
+ for ans in 1.. {
+ if q.is_empty() || cnt == 0 {
+ break;
+ }
+ let size = q.len();
+ for _ in 0..size {
+ let (i, j) = q.pop_front().unwrap();
+ for d in 0..4 {
+ let x = i as isize + dirs[d];
+ let y = j as isize + dirs[d + 1];
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let (x, y) = (x as usize, y as usize);
+ if grid[x][y] == 1 {
+ grid[x][y] = 2;
+ q.push_back((x, y));
+ cnt -= 1;
+ if cnt == 0 {
+ return ans;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if cnt > 0 { -1 } else { 0 }
+ }
+}
+```
+
+### **JavaScript**
+
+```js
+var orangesRotting = function(grid) {
+ const m = grid.length, n = grid[0].length;
+ let q = [], cnt = 0;
+ for (let i = 0; i < m; ++i) {
+ for (let j = 0; j < n; ++j) {
+ if (grid[i][j] === 2) q.push([i, j]);
+ else if (grid[i][j] === 1) cnt++;
+ }
+ }
+
+ const dirs = [-1, 0, 1, 0, -1];
+ for (let ans = 1; q.length && cnt > 0; ++ans) {
+ const t = [];
+ for (const [i, j] of q) {
+ for (let d = 0; d < 4; ++d) {
+ const x = i + dirs[d], y = j + dirs[d + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] === 1) {
+ grid[x][y] = 2;
+ t.push([x, y]);
+ cnt--;
+ if (cnt === 0) return ans;
+ }
+ }
+ }
+ q = t;
+ }
+ return cnt > 0 ? -1 : 0;
+};
+```
+
+
diff --git a/Solution/readme.md b/Solution/readme.md
new file mode 100644
index 0000000..d6f2414
--- /dev/null
+++ b/Solution/readme.md
@@ -0,0 +1,181 @@
+Here is a LeetCode-style problem description and solution for you, following the format you requested:
+
+---
+
+```yaml
+comments: true
+difficulty: Medium
+edit_url: https://github.com/doocs/leetcode/edit/main/solution/2300-2399/2300.Successful%20Pairs%20of%20Spells%20and%20Potions/README_EN.md
+rating: 1476
+source: Biweekly Contest 80 Q2
+tags:
+ - Array
+ - Two Pointers
+ - Binary Search
+ - Sorting
+```
+
+
+
+# [2300. Successful Pairs of Spells and Potions](https://leetcode.com/problems/successful-pairs-of-spells-and-potions)
+
+[δΈζζζ‘£](/solution/2300-2399/2300.Successful%20Pairs%20of%20Spells%20and%20Potions/README.md)
+
+## Description
+
+
+
+You are given two positive integer arrays spells and potions, of length n and m respectively, where spells[i] represents the strength of the ith spell and potions[j] represents the strength of the jth potion.
+
+You are also given an integer success. A spell and potion pair is considered successful if the product of their strengths is at least success.
+
+Return an integer array pairs of length n where pairs[i] is the number of potions that will form a successful pair with the ith spell.
+
+
+Example 1:
+
+
+Input: spells = [5,1,3], potions = [1,2,3,4,5], success = 7
+Output: [4,0,3]
+Explanation:
+- 0th spell: 5 * [1,2,3,4,5] = [5,10,15,20,25]. 4 pairs are successful.
+- 1st spell: 1 * [1,2,3,4,5] = [1,2,3,4,5]. 0 pairs are successful.
+- 2nd spell: 3 * [1,2,3,4,5] = [3,6,9,12,15]. 3 pairs are successful.
+Thus, [4,0,3] is returned.
+
+
+Example 2:
+
+
+Input: spells = [3,1,2], potions = [8,5,8], success = 16
+Output: [2,0,2]
+Explanation:
+- 0th spell: 3 * [8,5,8] = [24,15,24]. 2 pairs are successful.
+- 1st spell: 1 * [8,5,8] = [8,5,8]. 0 pairs are successful.
+- 2nd spell: 2 * [8,5,8] = [16,10,16]. 2 pairs are successful.
+Thus, [2,0,2] is returned.
+
+
+
+Constraints:
+
+
+ n == spells.lengthm == potions.length1 <= n, m <= 1051 <= spells[i], potions[i] <= 1051 <= success <= 1010
+
+
+
+## Solutions
+
+
+
+### Solution 1: Sorting + Binary Search
+
+We can sort the potion array, then traverse the spell array. For each spell $v$, we use binary search to find the first potion that is greater than or equal to $\frac{success}{v}$. We mark its index as $i$. The length of the potion array minus $i$ is the number of potions that can successfully combine with this spell.
+
+The time complexity is $O((m + n) \times \log m)$, and the space complexity is $O(\log n)$. Here, $m$ and $n$ are the lengths of the potion array and the spell array, respectively.
+
+
+
+#### Python3
+
+```python
+class Solution:
+ def successfulPairs(
+ self, spells: List[int], potions: List[int], success: int
+ ) -> List[int]:
+ potions.sort()
+ m = len(potions)
+ return [m - bisect_left(potions, success / v) for v in spells]
+```
+
+#### Java
+
+```java
+class Solution {
+ public int[] successfulPairs(int[] spells, int[] potions, long success) {
+ Arrays.sort(potions);
+ int n = spells.length, m = potions.length;
+ int[] ans = new int[n];
+ for (int i = 0; i < n; ++i) {
+ int left = 0, right = m;
+ while (left < right) {
+ int mid = (left + right) >> 1;
+ if ((long) spells[i] * potions[mid] >= success) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ ans[i] = m - left;
+ }
+ return ans;
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ vector successfulPairs(vector& spells, vector& potions, long long success) {
+ sort(potions.begin(), potions.end());
+ vector ans;
+ int m = potions.size();
+ for (int& v : spells) {
+ int i = lower_bound(potions.begin(), potions.end(), success * 1.0 / v) - potions.begin();
+ ans.push_back(m - i);
+ }
+ return ans;
+ }
+};
+```
+
+#### Go
+
+```go
+func successfulPairs(spells []int, potions []int, success int64) (ans []int) {
+ sort.Ints(potions)
+ m := len(potions)
+ for _, v := range spells {
+ i := sort.Search(m, func(i int) bool { return int64(potions[i]*v) >= success })
+ ans = append(ans, m-i)
+ }
+ return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function successfulPairs(spells: number[], potions: number[], success: number): number[] {
+ potions.sort((a, b) => a - b);
+ const m = potions.length;
+ const ans: number[] = [];
+ for (const v of spells) {
+ let left = 0;
+ let right = m;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (v * potions[mid] >= success) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ ans.push(m - left);
+ }
+ return ans;
+}
+```
+
+
+
+
+
+
+
+
+
+
+