diff --git a/solution/3500-3599/3562.Maximum Profit from Trading Stocks with Discounts/images/screenshot-2025-04-10-at-054114.png b/solution/3500-3599/3562.Maximum Profit from Trading Stocks with Discounts/images/screenshot-2025-04-10-at-054114.png new file mode 100644 index 0000000000000..b045b1e70c5d2 Binary files /dev/null and b/solution/3500-3599/3562.Maximum Profit from Trading Stocks with Discounts/images/screenshot-2025-04-10-at-054114.png differ diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/README.md b/solution/3500-3599/3565.Sequential Grid Path Cover/README.md index 126d702218cce..4a8d7bffe4c7f 100644 --- a/solution/3500-3599/3565.Sequential Grid Path Cover/README.md +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/README.md @@ -69,32 +69,294 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3565.Se -### 方法一 +### 方法一：状态压缩 + DFS + +我们注意到，矩阵的大小不超过 $6 \times 6$，因此可以使用状态压缩来表示已经访问过的格子。我们可以使用一个整数 $\textit{st}$ 来表示已经访问过的格子，其中第 $i$ 位为 1 表示格子 $i$ 已经被访问过，0 表示未被访问过。 + +接下来，我们遍历每一个格子作为起点，如果该格子是 0 或 1，则从该格子开始进行深度优先搜索（DFS）。在 DFS 中，我们将当前格子加入路径中，并将其标记为已访问。然后，我们检查当前格子的值，如果等于 $v$，则将 $v$ 加 1。接着，我们尝试向四个方向移动到相邻的格子，如果相邻格子未被访问且其值为 0 或 $v$，则继续进行 DFS。 + +如果 DFS 成功找到了一条完整的路径，则返回该路径。如果无法找到完整路径，则回溯，撤销当前格子的访问标记，并尝试其他方向。 + +时间复杂度 $O(m^2 \times n^2)$，空间复杂度 $O(m \times n)$，其中 $m$ 和 $n$ 分别是矩阵的行数和列数。 #### Python3 ```python - +class Solution: + def findPath(self, grid: List[List[int]], k: int) -> List[List[int]]: + def f(i: int, j: int) -> int: + return i * n + j + + def dfs(i: int, j: int, v: int): + nonlocal st + path.append([i, j]) + if len(path) == m * n: + return True + st |= 1 << f(i, j) + if grid[i][j] == v: + v += 1 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if ( + 0 <= x < m + and 0 <= y < n + and (st & 1 << f(x, y)) == 0 + and grid[x][y] in (0, v) + ): + if dfs(x, y, v): + return True + path.pop() + st ^= 1 << f(i, j) + return False + + m, n = len(grid), len(grid[0]) + st = 0 + path = [] + dirs = (-1, 0, 1, 0, -1) + for i in range(m): + for j in range(n): + if grid[i][j] in (0, 1): + if dfs(i, j, 1): + return path + path.clear() + st = 0 + return [] ``` #### Java ```java - +class Solution { + private int m, n; + private long st = 0; + private List> path = new ArrayList<>(); + private final int[] dirs = {-1, 0, 1, 0, -1}; + + private int f(int i, int j) { + return i * n + j; + } + + private boolean dfs(int i, int j, int v, int[][] grid) { + path.add(Arrays.asList(i, j)); + if (path.size() == m * n) { + return true; + } + st |= 1L << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; t++) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1L << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.remove(path.size() - 1); + st ^= 1L << f(i, j); + return false; + } + + public List> findPath(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return List.of(); + } +} ``` #### C++ ```cpp - +class Solution { + int m, n; + unsigned long long st = 0; + vector> path; + int dirs[5] = {-1, 0, 1, 0, -1}; + + int f(int i, int j) { + return i * n + j; + } + + bool dfs(int i, int j, int v, vector>& grid) { + path.push_back({i, j}); + if (path.size() == static_cast(m * n)) { + return true; + } + st |= 1ULL << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; ++t) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1ULL << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.pop_back(); + st ^= 1ULL << f(i, j); + return false; + } + +public: + vector> findPath(vector>& grid, int k) { + m = grid.size(); + n = grid[0].size(); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return {}; + } +}; ``` #### Go ```go +func findPath(grid [][]int, k int) [][]int { + _ = k + m := len(grid) + n := len(grid[0]) + var st uint64 + path := [][]int{} + dirs := []int{-1, 0, 1, 0, -1} + + f := func(i, j int) int { return i*n + j } + + var dfs func(int, int, int) bool + dfs = func(i, j, v int) bool { + path = append(path, []int{i, j}) + if len(path) == m*n { + return true + } + idx := f(i, j) + st |= 1 << idx + if grid[i][j] == v { + v++ + } + for t := 0; t < 4; t++ { + a, b := dirs[t], dirs[t+1] + x, y := i+a, j+b + if 0 <= x && x < m && 0 <= y && y < n { + idx2 := f(x, y) + if (st>>idx2)&1 == 0 && (grid[x][y] == 0 || grid[x][y] == v) { + if dfs(x, y, v) { + return true + } + } + } + } + path = path[:len(path)-1] + st ^= 1 << idx + return false + } + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 0 || grid[i][j] == 1 { + if dfs(i, j, 1) { + return path + } + path = path[:0] + st = 0 + } + } + } + return [][]int{} +} +``` +#### TypeScript + +```ts +function findPath(grid: number[][], k: number): number[][] { + const m = grid.length; + const n = grid[0].length; + + const dirs = [-1, 0, 1, 0, -1]; + const path: number[][] = []; + let st = 0; + + function f(i: number, j: number): number { + return i * n + j; + } + + function dfs(i: number, j: number, v: number): boolean { + path.push([i, j]); + if (path.length === m * n) { + return true; + } + + st |= 1 << f(i, j); + if (grid[i][j] === v) { + v += 1; + } + + for (let d = 0; d < 4; d++) { + const x = i + dirs[d]; + const y = j + dirs[d + 1]; + const pos = f(x, y); + if ( + x >= 0 && + x < m && + y >= 0 && + y < n && + (st & (1 << pos)) === 0 && + (grid[x][y] === 0 || grid[x][y] === v) + ) { + if (dfs(x, y, v)) { + return true; + } + } + } + + path.pop(); + st ^= 1 << f(i, j); + return false; + } + + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] === 0 || grid[i][j] === 1) { + st = 0; + path.length = 0; + if (dfs(i, j, 1)) { + return path; + } + } + } + } + + return []; +} ``` diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/README_EN.md b/solution/3500-3599/3565.Sequential Grid Path Cover/README_EN.md index c4d787d6c17db..824f3f36679eb 100644 --- a/solution/3500-3599/3565.Sequential Grid Path Cover/README_EN.md +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/README_EN.md @@ -69,32 +69,294 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3565.Se -### Solution 1 +### Solution 1: State Compression + DFS + +Note that the matrix size does not exceed $6 \times 6$, so we can use state compression to represent the visited cells. We can use an integer $\textit{st}$ to represent the visited cells, where the $i$-th bit being 1 means cell $i$ has been visited, and 0 means it has not been visited. + +Next, we iterate through each cell as a starting point. If the cell is 0 or 1, we start a depth-first search (DFS) from that cell. In the DFS, we add the current cell to the path and mark it as visited. Then, we check the value of the current cell. If it equals $v$, we increment $v$ by 1. Next, we try to move in four directions to adjacent cells. If the adjacent cell has not been visited and its value is 0 or $v$, we continue the DFS. + +If the DFS successfully finds a complete path, we return that path. If a complete path cannot be found, we backtrack, undo the visit mark for the current cell, and try other directions. + +The time complexity is $O(m^2 \times n^2)$, and the space complexity is $O(m \times n)$, where $m$ and $n$ are the number of rows and columns of the matrix, respectively. #### Python3 ```python - +class Solution: + def findPath(self, grid: List[List[int]], k: int) -> List[List[int]]: + def f(i: int, j: int) -> int: + return i * n + j + + def dfs(i: int, j: int, v: int): + nonlocal st + path.append([i, j]) + if len(path) == m * n: + return True + st |= 1 << f(i, j) + if grid[i][j] == v: + v += 1 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if ( + 0 <= x < m + and 0 <= y < n + and (st & 1 << f(x, y)) == 0 + and grid[x][y] in (0, v) + ): + if dfs(x, y, v): + return True + path.pop() + st ^= 1 << f(i, j) + return False + + m, n = len(grid), len(grid[0]) + st = 0 + path = [] + dirs = (-1, 0, 1, 0, -1) + for i in range(m): + for j in range(n): + if grid[i][j] in (0, 1): + if dfs(i, j, 1): + return path + path.clear() + st = 0 + return [] ``` #### Java ```java - +class Solution { + private int m, n; + private long st = 0; + private List> path = new ArrayList<>(); + private final int[] dirs = {-1, 0, 1, 0, -1}; + + private int f(int i, int j) { + return i * n + j; + } + + private boolean dfs(int i, int j, int v, int[][] grid) { + path.add(Arrays.asList(i, j)); + if (path.size() == m * n) { + return true; + } + st |= 1L << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; t++) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1L << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.remove(path.size() - 1); + st ^= 1L << f(i, j); + return false; + } + + public List> findPath(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return List.of(); + } +} ``` #### C++ ```cpp - +class Solution { + int m, n; + unsigned long long st = 0; + vector> path; + int dirs[5] = {-1, 0, 1, 0, -1}; + + int f(int i, int j) { + return i * n + j; + } + + bool dfs(int i, int j, int v, vector>& grid) { + path.push_back({i, j}); + if (path.size() == static_cast(m * n)) { + return true; + } + st |= 1ULL << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; ++t) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1ULL << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.pop_back(); + st ^= 1ULL << f(i, j); + return false; + } + +public: + vector> findPath(vector>& grid, int k) { + m = grid.size(); + n = grid[0].size(); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return {}; + } +}; ``` #### Go ```go +func findPath(grid [][]int, k int) [][]int { + _ = k + m := len(grid) + n := len(grid[0]) + var st uint64 + path := [][]int{} + dirs := []int{-1, 0, 1, 0, -1} + + f := func(i, j int) int { return i*n + j } + + var dfs func(int, int, int) bool + dfs = func(i, j, v int) bool { + path = append(path, []int{i, j}) + if len(path) == m*n { + return true + } + idx := f(i, j) + st |= 1 << idx + if grid[i][j] == v { + v++ + } + for t := 0; t < 4; t++ { + a, b := dirs[t], dirs[t+1] + x, y := i+a, j+b + if 0 <= x && x < m && 0 <= y && y < n { + idx2 := f(x, y) + if (st>>idx2)&1 == 0 && (grid[x][y] == 0 || grid[x][y] == v) { + if dfs(x, y, v) { + return true + } + } + } + } + path = path[:len(path)-1] + st ^= 1 << idx + return false + } + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 0 || grid[i][j] == 1 { + if dfs(i, j, 1) { + return path + } + path = path[:0] + st = 0 + } + } + } + return [][]int{} +} +``` +#### TypeScript + +```ts +function findPath(grid: number[][], k: number): number[][] { + const m = grid.length; + const n = grid[0].length; + + const dirs = [-1, 0, 1, 0, -1]; + const path: number[][] = []; + let st = 0; + + function f(i: number, j: number): number { + return i * n + j; + } + + function dfs(i: number, j: number, v: number): boolean { + path.push([i, j]); + if (path.length === m * n) { + return true; + } + + st |= 1 << f(i, j); + if (grid[i][j] === v) { + v += 1; + } + + for (let d = 0; d < 4; d++) { + const x = i + dirs[d]; + const y = j + dirs[d + 1]; + const pos = f(x, y); + if ( + x >= 0 && + x < m && + y >= 0 && + y < n && + (st & (1 << pos)) === 0 && + (grid[x][y] === 0 || grid[x][y] === v) + ) { + if (dfs(x, y, v)) { + return true; + } + } + } + + path.pop(); + st ^= 1 << f(i, j); + return false; + } + + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] === 0 || grid[i][j] === 1) { + st = 0; + path.length = 0; + if (dfs(i, j, 1)) { + return path; + } + } + } + } + + return []; +} ``` diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.cpp b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.cpp new file mode 100644 index 0000000000000..333b198e3054c --- /dev/null +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.cpp @@ -0,0 +1,52 @@ +class Solution { + int m, n; + unsigned long long st = 0; + vector> path; + int dirs[5] = {-1, 0, 1, 0, -1}; + + int f(int i, int j) { + return i * n + j; + } + + bool dfs(int i, int j, int v, vector>& grid) { + path.push_back({i, j}); + if (path.size() == static_cast(m * n)) { + return true; + } + st |= 1ULL << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; ++t) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1ULL << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.pop_back(); + st ^= 1ULL << f(i, j); + return false; + } + +public: + vector> findPath(vector>& grid, int k) { + m = grid.size(); + n = grid[0].size(); + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return {}; + } +}; diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.go b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.go new file mode 100644 index 0000000000000..79800be3f9791 --- /dev/null +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.go @@ -0,0 +1,51 @@ +func findPath(grid [][]int, k int) [][]int { + _ = k + m := len(grid) + n := len(grid[0]) + var st uint64 + path := [][]int{} + dirs := []int{-1, 0, 1, 0, -1} + + f := func(i, j int) int { return i*n + j } + + var dfs func(int, int, int) bool + dfs = func(i, j, v int) bool { + path = append(path, []int{i, j}) + if len(path) == m*n { + return true + } + idx := f(i, j) + st |= 1 << idx + if grid[i][j] == v { + v++ + } + for t := 0; t < 4; t++ { + a, b := dirs[t], dirs[t+1] + x, y := i+a, j+b + if 0 <= x && x < m && 0 <= y && y < n { + idx2 := f(x, y) + if (st>>idx2)&1 == 0 && (grid[x][y] == 0 || grid[x][y] == v) { + if dfs(x, y, v) { + return true + } + } + } + } + path = path[:len(path)-1] + st ^= 1 << idx + return false + } + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 0 || grid[i][j] == 1 { + if dfs(i, j, 1) { + return path + } + path = path[:0] + st = 0 + } + } + } + return [][]int{} +} diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.java b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.java new file mode 100644 index 0000000000000..f0bdf2b2160f6 --- /dev/null +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.java @@ -0,0 +1,51 @@ +class Solution { + private int m, n; + private long st = 0; + private List> path = new ArrayList<>(); + private final int[] dirs = {-1, 0, 1, 0, -1}; + + private int f(int i, int j) { + return i * n + j; + } + + private boolean dfs(int i, int j, int v, int[][] grid) { + path.add(Arrays.asList(i, j)); + if (path.size() == m * n) { + return true; + } + st |= 1L << f(i, j); + if (grid[i][j] == v) { + v += 1; + } + for (int t = 0; t < 4; t++) { + int a = dirs[t], b = dirs[t + 1]; + int x = i + a, y = j + b; + if (0 <= x && x < m && 0 <= y && y < n && (st & (1L << f(x, y))) == 0 + && (grid[x][y] == 0 || grid[x][y] == v)) { + if (dfs(x, y, v, grid)) { + return true; + } + } + } + path.remove(path.size() - 1); + st ^= 1L << f(i, j); + return false; + } + + public List> findPath(int[][] grid, int k) { + m = grid.length; + n = grid[0].length; + for (int i = 0; i < m; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 0 || grid[i][j] == 1) { + if (dfs(i, j, 1, grid)) { + return path; + } + path.clear(); + st = 0; + } + } + } + return List.of(); + } +} diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.py b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.py new file mode 100644 index 0000000000000..c04b0f93a72ff --- /dev/null +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.py @@ -0,0 +1,39 @@ +class Solution: + def findPath(self, grid: List[List[int]], k: int) -> List[List[int]]: + def f(i: int, j: int) -> int: + return i * n + j + + def dfs(i: int, j: int, v: int): + nonlocal st + path.append([i, j]) + if len(path) == m * n: + return True + st |= 1 << f(i, j) + if grid[i][j] == v: + v += 1 + for a, b in pairwise(dirs): + x, y = i + a, j + b + if ( + 0 <= x < m + and 0 <= y < n + and (st & 1 << f(x, y)) == 0 + and grid[x][y] in (0, v) + ): + if dfs(x, y, v): + return True + path.pop() + st ^= 1 << f(i, j) + return False + + m, n = len(grid), len(grid[0]) + st = 0 + path = [] + dirs = (-1, 0, 1, 0, -1) + for i in range(m): + for j in range(n): + if grid[i][j] in (0, 1): + if dfs(i, j, 1): + return path + path.clear() + st = 0 + return [] diff --git a/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.ts b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.ts new file mode 100644 index 0000000000000..a5679288367fd --- /dev/null +++ b/solution/3500-3599/3565.Sequential Grid Path Cover/Solution.ts @@ -0,0 +1,60 @@ +function findPath(grid: number[][], k: number): number[][] { + const m = grid.length; + const n = grid[0].length; + + const dirs = [-1, 0, 1, 0, -1]; + const path: number[][] = []; + let st = 0; + + function f(i: number, j: number): number { + return i * n + j; + } + + function dfs(i: number, j: number, v: number): boolean { + path.push([i, j]); + if (path.length === m * n) { + return true; + } + + st |= 1 << f(i, j); + if (grid[i][j] === v) { + v += 1; + } + + for (let d = 0; d < 4; d++) { + const x = i + dirs[d]; + const y = j + dirs[d + 1]; + const pos = f(x, y); + if ( + x >= 0 && + x < m && + y >= 0 && + y < n && + (st & (1 << pos)) === 0 && + (grid[x][y] === 0 || grid[x][y] === v) + ) { + if (dfs(x, y, v)) { + return true; + } + } + } + + path.pop(); + st ^= 1 << f(i, j); + return false; + } + + for (let i = 0; i < m; i++) { + for (let j = 0; j < n; j++) { + if (grid[i][j] === 0 || grid[i][j] === 1) { + st = 0; + path.length = 0; + if (dfs(i, j, 1)) { + return path; + } + } + } + } + + return []; +}