feat: add solutions to lc problem: No.0133

No.0133.Clone Graph

Author: yanglbme

solution/0100-0199/0133.Clone Graph/README.md

@@ -76,7 +76,6 @@
 	<li>图是连通图，你可以从给定节点访问到所有节点。</li>
 </ol>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -88,15 +87,76 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+
+class Solution:
+    def cloneGraph(self, node: 'Node') -> 'Node':
+        visited = defaultdict()
+
+        def clone(node):
+            if node is None:
+                return None
+            if node in visited:
+                return visited[node]
+            c = Node(node.val)
+            visited[node] = c
+            for e in node.neighbors:
+                c.neighbors.append(clone(e))
+            return c
+
+        return clone(node)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    private Map<Node, Node> visited = new HashMap<>();
 
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+        if (visited.containsKey(node)) {
+            return visited.get(node);
+        }
+        Node clone = new Node(node.val);
+        visited.put(node, clone);
+        for (Node e : node.neighbors) {
+            clone.neighbors.add(cloneGraph(e));
+        }
+        return clone;
+    }
+}
 ```
 
 ### **TypeScript**
@@ -114,7 +174,7 @@
  * }
  */
 
-function cloneGraph(node: Node | null): Node | null {
+ function cloneGraph(node: Node | null): Node | null {
     if (node == null) return null;
 
     const visited = new Map();
@@ -136,6 +196,79 @@ function cloneGraph(node: Node | null): Node | null {
 };
 ```
 
+### **C++**
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> neighbors;
+    Node() {
+        val = 0;
+        neighbors = vector<Node*>();
+    }
+    Node(int _val) {
+        val = _val;
+        neighbors = vector<Node*>();
+    }
+    Node(int _val, vector<Node*> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+};
+*/
+
+class Solution {
+public:
+    unordered_map<Node*, Node*> visited;
+
+    Node* cloneGraph(Node* node) {
+        if (!node) return nullptr;
+        if (visited.count(node)) return visited[node];
+        Node* clone = new Node(node->val);
+        visited[node] = clone;
+        for (auto& e : node->neighbors)
+            clone->neighbors.push_back(cloneGraph(e));
+        return clone;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Neighbors []*Node
+ * }
+ */
+
+func cloneGraph(node *Node) *Node {
+	visited := map[*Node]*Node{}
+	var clone func(node *Node) *Node
+	clone = func(node *Node) *Node {
+		if node == nil {
+			return nil
+		}
+		if _, ok := visited[node]; ok {
+			return visited[node]
+		}
+		c := &Node{node.Val, []*Node{}}
+		visited[node] = c
+		for _, e := range node.Neighbors {
+			c.Neighbors = append(c.Neighbors, clone(e))
+		}
+		return c
+	}
+
+	return clone(node)
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0133.Clone Graph/README_EN.md

@@ -6,16 +6,10 @@
 
 <p>Given a reference of a node in a&nbsp;<strong><a href="https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph" target="_blank">connected</a></strong>&nbsp;undirected graph.</p>
 
-
-
 <p>Return a <a href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy" target="_blank"><strong>deep copy</strong></a> (clone) of the graph.</p>
 
-
-
 <p>Each node in the graph contains a val (<code>int</code>) and a list (<code>List[Node]</code>) of its neighbors.</p>
 
-
-
 <pre>
 
 class Node {
@@ -28,27 +22,16 @@ class Node {
 
 </pre>
 
-
-
 <p>&nbsp;</p>
 
-
-
 <p><strong>Test case format:</strong></p>
 
-
-
 <p>For simplicity sake, each&nbsp;node&#39;s value is the same as the node&#39;s index (1-indexed). For example, the first node with&nbsp;<code>val = 1</code>, the second node with <code>val = 2</code>, and so on.&nbsp;The graph is represented in the test case using an adjacency list.</p>
 
-
-
 <p><b>Adjacency list</b>&nbsp;is a collection of unordered&nbsp;<b>lists</b>&nbsp;used to represent a finite graph. Each&nbsp;list&nbsp;describes the set of neighbors of a node in the graph.</p>
 
-
-
 <p>The given node will&nbsp;always be the first node&nbsp;with&nbsp;<code>val = 1</code>. You must return the <strong>copy of the given node</strong> as a reference to the cloned graph.</p>
 
-
 <p>&nbsp;</p>
 <p><strong>Example 1:</strong></p>
 <img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0133.Clone%20Graph/images/133_clone_graph_question.png" style="width: 500px; height: 550px;" />
@@ -96,21 +79,81 @@ class Node {
 	<li>The Graph is connected and all nodes can be visited starting from the given node.</li>
 </ul>
 
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+
+class Solution:
+    def cloneGraph(self, node: 'Node') -> 'Node':
+        visited = defaultdict()
+
+        def clone(node):
+            if node is None:
+                return None
+            if node in visited:
+                return visited[node]
+            c = Node(node.val)
+            visited[node] = c
+            for e in node.neighbors:
+                c.neighbors.append(clone(e))
+            return c
+
+        return clone(node)
 ```
 
 ### **Java**
 
 ```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
 
+class Solution {
+    private Map<Node, Node> visited = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+        if (visited.containsKey(node)) {
+            return visited.get(node);
+        }
+        Node clone = new Node(node.val);
+        visited.put(node, clone);
+        for (Node e : node.neighbors) {
+            clone.neighbors.add(cloneGraph(e));
+        }
+        return clone;
+    }
+}
 ```
 
 ### **TypeScript**
@@ -128,7 +171,7 @@ class Node {
  * }
  */
 
-function cloneGraph(node: Node | null): Node | null {
+ function cloneGraph(node: Node | null): Node | null {
     if (node == null) return null;
 
     const visited = new Map();
@@ -150,6 +193,79 @@ function cloneGraph(node: Node | null): Node | null {
 };
 ```
 
+### **C++**
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> neighbors;
+    Node() {
+        val = 0;
+        neighbors = vector<Node*>();
+    }
+    Node(int _val) {
+        val = _val;
+        neighbors = vector<Node*>();
+    }
+    Node(int _val, vector<Node*> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+};
+*/
+
+class Solution {
+public:
+    unordered_map<Node*, Node*> visited;
+
+    Node* cloneGraph(Node* node) {
+        if (!node) return nullptr;
+        if (visited.count(node)) return visited[node];
+        Node* clone = new Node(node->val);
+        visited[node] = clone;
+        for (auto& e : node->neighbors)
+            clone->neighbors.push_back(cloneGraph(e));
+        return clone;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Neighbors []*Node
+ * }
+ */
+
+func cloneGraph(node *Node) *Node {
+	visited := map[*Node]*Node{}
+	var clone func(node *Node) *Node
+	clone = func(node *Node) *Node {
+		if node == nil {
+			return nil
+		}
+		if _, ok := visited[node]; ok {
+			return visited[node]
+		}
+		c := &Node{node.Val, []*Node{}}
+		visited[node] = c
+		for _, e := range node.Neighbors {
+			c.Neighbors = append(c.Neighbors, clone(e))
+		}
+		return c
+	}
+
+	return clone(node)
+}
+```
+
 ### **...**
 
 ```