From f4f19c843983115293abe8134abc0175a3760e5d Mon Sep 17 00:00:00 2001 From: yanglbme Date: Tue, 27 May 2025 09:43:36 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.3565 No.3565.Sequential Grid Path Cover --- .../screenshot-2025-04-10-at-054114.png | Bin 0 -> 18538 bytes .../3565.Sequential Grid Path Cover/README.md | 270 +++++++++++++++++- .../README_EN.md | 270 +++++++++++++++++- .../Solution.cpp | 52 ++++ .../Solution.go | 51 ++++ .../Solution.java | 51 ++++ .../Solution.py | 39 +++ .../Solution.ts | 60 ++++ 8 files changed, 785 insertions(+), 8 deletions(-) create mode 100644 solution/3500-3599/3562.Maximum Profit from Trading Stocks with Discounts/images/screenshot-2025-04-10-at-054114.png create mode 100644 solution/3500-3599/3565.Sequential Grid Path Cover/Solution.cpp create mode 100644 solution/3500-3599/3565.Sequential Grid Path Cover/Solution.go create mode 100644 solution/3500-3599/3565.Sequential Grid Path Cover/Solution.java create mode 100644 solution/3500-3599/3565.Sequential Grid Path Cover/Solution.py create mode 100644 solution/3500-3599/3565.Sequential Grid Path Cover/Solution.ts 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 0000000000000000000000000000000000000000..b045b1e70c5d24fd4f73dac291fb322a55c8d10e GIT binary patch literal 18538 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 literal 0 HcmV?d00001 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 []; +}