feat: add solutions to lc problem: No.0694

No.0694.Number of Distinct Islands

Author: yanglbme

solution/0000-0099/0017.Letter Combinations of a Phone Number/README.md

@@ -114,7 +114,7 @@ class Solution {
 ### **Go**
 
 ```go
-var table = map[string][]string {
+var table = map[string][]string{
 	"2": {"a", "b", "c"},
 	"3": {"d", "e", "f"},
 	"4": {"g", "h", "i"},
@@ -130,12 +130,12 @@ func letterCombinations(digits string) []string {
 		return make([]string, 0)
 	}
 	var result = table[string(digits[0])]
-	for i:=1; i<len(digits); i++ {
+	for i := 1; i < len(digits); i++ {
 		t := table[string(digits[i])]
-		nr := make([]string, len(result) * len(t))
-		for j:=0; j<len(result); j++ {
-			for k:=0; k<len(t); k++ {
-				nr[len(t)*j + k] = result[j] + t[k]
+		nr := make([]string, len(result)*len(t))
+		for j := 0; j < len(result); j++ {
+			for k := 0; k < len(t); k++ {
+				nr[len(t)*j+k] = result[j] + t[k]
 			}
 		}
 		result = nr

solution/0000-0099/0017.Letter Combinations of a Phone Number/README_EN.md

@@ -104,7 +104,7 @@ class Solution {
 ### **Go**
 
 ```go
-var table = map[string][]string {
+var table = map[string][]string{
 	"2": {"a", "b", "c"},
 	"3": {"d", "e", "f"},
 	"4": {"g", "h", "i"},
@@ -120,12 +120,12 @@ func letterCombinations(digits string) []string {
 		return make([]string, 0)
 	}
 	var result = table[string(digits[0])]
-	for i:=1; i<len(digits); i++ {
+	for i := 1; i < len(digits); i++ {
 		t := table[string(digits[i])]
-		nr := make([]string, len(result) * len(t))
-		for j:=0; j<len(result); j++ {
-			for k:=0; k<len(t); k++ {
-				nr[len(t)*j + k] = result[j] + t[k]
+		nr := make([]string, len(result)*len(t))
+		for j := 0; j < len(result); j++ {
+			for k := 0; k < len(t); k++ {
+				nr[len(t)*j+k] = result[j] + t[k]
 			}
 		}
 		result = nr

solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.go

@@ -1,4 +1,4 @@
-var table = map[string][]string {
+var table = map[string][]string{
 	"2": {"a", "b", "c"},
 	"3": {"d", "e", "f"},
 	"4": {"g", "h", "i"},
@@ -14,12 +14,12 @@ func letterCombinations(digits string) []string {
 		return make([]string, 0)
 	}
 	var result = table[string(digits[0])]
-	for i:=1; i<len(digits); i++ {
+	for i := 1; i < len(digits); i++ {
 		t := table[string(digits[i])]
-		nr := make([]string, len(result) * len(t))
-		for j:=0; j<len(result); j++ {
-			for k:=0; k<len(t); k++ {
-				nr[len(t)*j + k] = result[j] + t[k]
+		nr := make([]string, len(result)*len(t))
+		for j := 0; j < len(result); j++ {
+			for k := 0; k < len(t); k++ {
+				nr[len(t)*j+k] = result[j] + t[k]
 			}
 		}
 		result = nr

solution/0600-0699/0694.Number of Distinct Islands/README.md

@@ -53,22 +53,152 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+遍历网格，若坐标点 `(i, j)` 对应的值是 1，进行 DFS 遍历，找到对应的岛屿，并且将遍历方向进行序列化，用哈希表存储。最后返回哈希表的大小即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def numDistinctIslands(self, grid: List[List[int]]) -> int:
+        def dfs(i, j, direction, path):
+            grid[i][j] = 0
+            path.append(str(direction))
+            dirs = [-1, 0, 1, 0, -1]
+            for k in range(1, 5):
+                x, y = i + dirs[k - 1], j + dirs[k]
+                if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+                    dfs(x, y, k, path)
+            path.append(str(-direction))
+
+        paths = set()
+        path = []
+        m, n = len(grid), len(grid[0])
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    dfs(i, j, 0, path)
+                    paths.add(''.join(path))
+                    path.clear()
+        return len(paths)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int m;
+    private int n;
+    private int[][] grid;
+
+    public int numDistinctIslands(int[][] grid) {
+        m = grid.length;
+        n = grid[0].length;
+        this.grid = grid;
+        Set<String> paths = new HashSet<>();
+
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    StringBuilder path = new StringBuilder();
+                    dfs(i, j, 0, path);
+                    paths.add(path.toString());
+                }
+            }
+        }
+        return paths.size();
+    }
+
+    private void dfs(int i, int j, int direction, StringBuilder path) {
+        grid[i][j] = 0;
+        path.append(direction);
+        int[] dirs = {-1, 0, 1, 0, -1};
+        for (int k = 1; k < 5; ++k) {
+            int x = i + dirs[k - 1];
+            int y = j + dirs[k];
+            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
+                dfs(x, y, k, path);
+            }
+        }
+        path.append(direction);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int numDistinctIslands(vector<vector<int>>& grid) {
+        unordered_set<string> paths;
+        string path;
+        for (int i = 0; i < grid.size(); ++i)
+        {
+            for (int j = 0; j < grid[0].size(); ++j)
+            {
+                if (grid[i][j] == 1)
+                {
+                    path = "";
+                    dfs(i, j, 0, grid, path);
+                    paths.insert(path);
+                }
+            }
+        }
+        return paths.size();
+    }
+
+    void dfs(int i, int j, int direction, vector<vector<int>>& grid, string& path) {
+        grid[i][j] = 0;
+        path += to_string(direction);
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        for (int k = 1; k < 5; ++k)
+        {
+            int x = i + dirs[k - 1], y = j + dirs[k];
+            if (x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size() && grid[x][y] == 1)
+                dfs(x, y, k, grid, path);
+        }
+        path += to_string(direction);
+    }
+};
+```
 
+### **Go**
+
+```go
+func numDistinctIslands(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	paths := make(map[string]bool)
+	path := ""
+	var dfs func(i, j, direction int)
+	dfs = func(i, j, direction int) {
+		grid[i][j] = 0
+		path += strconv.Itoa(direction)
+		dirs := []int{-1, 0, 1, 0, -1}
+		for k := 1; k < 5; k++ {
+			x, y := i+dirs[k-1], j+dirs[k]
+			if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 {
+				dfs(x, y, k)
+			}
+		}
+		path += strconv.Itoa(direction)
+	}
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				path = ""
+				dfs(i, j, 0)
+				paths[path] = true
+			}
+		}
+	}
+	return len(paths)
+}
 ```
 
 ### **...**