Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

clone-graph/HoonDongKang.ts

@@ -0,0 +1,65 @@
+/**
+ * [Problem]: [133] Clone Graph
+ * (https://leetcode.com/problems/longest-repeating-character-replacement/description/)
+ */
+
+//  Definition for _Node.
+class _Node {
+    val: number;
+    neighbors: _Node[];
+
+    constructor(val?: number, neighbors?: _Node[]) {
+        this.val = val === undefined ? 0 : val;
+        this.neighbors = neighbors === undefined ? [] : neighbors;
+    }
+}
+
+function cloneGraph(node: _Node | null): _Node | null {
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    function dfsFunc(node: _Node | null): _Node | null {
+        if (!node) return null;
+        const map = new Map<_Node, _Node>();
+
+        function dfs(node: _Node): _Node {
+            if (map.has(node)) return map.get(node)!;
+
+            const copy = new _Node(node.val);
+            map.set(node, copy);
+
+            for (const neighbor of node.neighbors) {
+                copy.neighbors.push(dfs(neighbor));
+            }
+
+            return copy;
+        }
+
+        return dfs(node);
+    }
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    function bfsFunc(node: _Node | null): _Node | null {
+        if (!node) return null;
+
+        const map = new Map<_Node, _Node>();
+        const queue: _Node[] = [];
+
+        const clone = new _Node(node.val);
+        map.set(node, clone);
+        queue.push(node);
+
+        while (queue.length > 0) {
+            const cur = queue.shift()!;
+
+            for (const neighbor of cur.neighbors) {
+                if (!map.has(neighbor)) {
+                    map.set(neighbor, new _Node(neighbor.val));
+                    queue.push(neighbor);
+                }
+
+                map.get(cur)!.neighbors.push(map.get(neighbor)!);
+            }
+        }
+        return clone;
+    }
+}

clone-graph/Jeehay28.ts

@@ -0,0 +1,67 @@
+class _Node {
+  val: number;
+  neighbors: _Node[];
+
+  constructor(val?: number, neighbors?: _Node[]) {
+    this.val = val === undefined ? 0 : val;
+    this.neighbors = neighbors === undefined ? [] : neighbors;
+  }
+}
+
+// TC: O(V + E), where V is the number of vertices and E is the number of edges
+// SC: O(V + E)
+function cloneGraph(node: _Node | null): _Node | null {
+  // 1: [2, 4]
+  // 2: [1, 3]
+  // 3: [2, 4]
+  // 4: [1, 3]
+
+  const clones = new Map<_Node, _Node>();
+  // original Node: cloned Node
+
+  if (!node) return null;
+
+  const dfs = (node: _Node) => {
+    if (clones.has(node)) {
+      return clones.get(node);
+    }
+
+    const clone = new _Node(node.val);
+    clones.set(node, clone);
+
+    for (const nei of node.neighbors) {
+      clone.neighbors.push(dfs(nei)!);
+    }
+
+    return clone;
+  };
+
+  return dfs(node)!;
+}
+
+
+// TC: O(V + E)
+// SC: O(V + E)
+// function cloneGraph(node: _Node | null): _Node | null {
+//   if (!node) return null;
+
+//   const clone: _Node = new _Node(node.val);
+//   const clones = new Map<_Node, _Node>();
+//   clones.set(node, clone);
+//   const queue: _Node[] = [node]; // BFS -> use queue
+
+//   while (queue.length > 0) {
+//     const node = queue.shift()!;
+//     for (const nei of node.neighbors) {
+//       if (!clones.has(nei)) {
+//         clones.set(nei, new _Node(nei.val));
+//         queue.push(nei);
+//       }
+//       clones.get(node)!.neighbors.push(clones.get(nei)!);
+//     }
+//   }
+
+//   return clone;
+// }
+
+

clone-graph/PDKhan.cpp

@@ -0,0 +1,31 @@
+class Solution {
+    public:
+        void dfs(Node* node, unordered_map<Node*, Node*>& map){
+            if(map.count(node))
+                return;
+            
+            map[node] = new Node(node->val);
+    
+            for(int i = 0; i < node->neighbors.size(); i++)
+                dfs(node->neighbors[i], map);
+        }
+    
+        Node* cloneGraph(Node* node) {
+            if(node == NULL)
+                return NULL;
+    
+            unordered_map<Node*, Node*> map;
+    
+            dfs(node, map);
+    
+            for(auto& x : map){
+                Node* org = x.first;
+                Node* dst = x.second;
+                for(int i = 0; i < org->neighbors.size(); i++){
+                    dst->neighbors.push_back(map[org->neighbors[i]]);
+                }
+            }
+            
+            return map[node];
+        }
+    };

clone-graph/Tessa1217.java

@@ -0,0 +1,59 @@
+/*
+// 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;
+    }
+}
+*/
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 참조 노드는 무방향 그래프에 연결되어있다. 그래프의 deep copy(clone)을 반환하세요.
+ */
+class Solution {
+
+    // 방문한 노드를 기억할 Map 선언
+    Map<Node, Node> visited = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        return clone(node);
+    }
+
+    public Node clone(Node node) {
+        if (node == null) {
+            return null;
+        }
+
+        // 이미 방문했으면 Map에서 꺼내서 반환
+        if (visited.containsKey(node)) {
+            return visited.get(node);
+        }
+
+        // 신규 Node 생성
+        Node newNode = new Node(node.val);
+        visited.put(node, newNode);
+
+        // 인접 노드 Clone
+        if (node.neighbors != null && !node.neighbors.isEmpty()) {
+            for (Node neighbor : node.neighbors) {
+                newNode.neighbors.add(clone(neighbor));
+            }
+        }
+        return newNode;
+    }
+}
+

clone-graph/ayosecu.py

@@ -0,0 +1,85 @@
+from typing import Optional
+from collections import deque
+
+# 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:
+    """
+        - Time Complexity: O(N + E)
+            - N = The number of nodes
+            - E = The number of neighbors
+        - Space Complexity: O(N + E)
+    """
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+        
+        dq = deque([node])
+        dic = {}
+        dic[node] = Node(node.val)
+
+        while dq:
+            pop_node = dq.popleft()        
+
+            for n in pop_node.neighbors:
+                if n not in dic:
+                    dq.append(n)
+                    dic[n] = Node(n.val)
+                dic[pop_node].neighbors.append(dic[n])
+
+        return dic[node]             
+
+
+### TEST CASES ###
+def build_graph(adj_list):
+    if not adj_list:
+        return None
+
+    nodes = {}
+    for i in range(1, len(adj_list) + 1):
+        nodes[i] = Node(i)
+
+    for i, neighbors in enumerate(adj_list, 1):
+        nodes[i].neighbors = [nodes[n] for n in neighbors]
+
+    return nodes[1]
+
+
+def print_graph(node):
+    if not node:
+        print("None")
+        return
+    
+    visited = set()
+    q = deque([node])
+    while q:
+        curr = q.popleft()
+        if curr in visited:
+            continue
+        visited.add(curr)
+        print(f"Node {curr.val}: {[n.val for n in curr.neighbors]}")
+        for neighbor in curr.neighbors:
+            if neighbor not in visited:
+                q.append(neighbor)
+
+tc = [
+        [[2,4],[1,3],[2,4],[1,3]],
+        [[]],
+        []
+]
+
+sol = Solution()
+for i, adj_list in enumerate(tc, 1):
+    original = build_graph(adj_list)
+    print(f"===== TC {i} =====")
+    print("Original Graph:")
+    print_graph(original)
+
+    cloned = sol.cloneGraph(original)
+
+    print("\nCloned Graph:")
+    print_graph(cloned)

clone-graph/clara-shin.js

@@ -0,0 +1,37 @@
+/**
+ * BFS를 사용한 그래프 복제
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) return null;
+
+  // 원본 노드와 복제된 노드를 매핑하는 해시맵
+  const cloned = new Map();
+
+  // BFS를 위한 큐
+  const queue = [node];
+
+  // 시작 노드 복제
+  cloned.set(node, new _Node(node.val));
+
+  while (queue.length > 0) {
+    const currentNode = queue.shift();
+
+    // 현재 노드의 모든 이웃들을 처리
+    for (let neighbor of currentNode.neighbors) {
+      // 이웃이 아직 복제되지 않았다면
+      if (!cloned.has(neighbor)) {
+        // 새로운 노드 생성하고 맵에 저장
+        cloned.set(neighbor, new _Node(neighbor.val));
+        // 큐에 추가하여 나중에 처리
+        queue.push(neighbor);
+      }
+
+      // 복제된 현재 노드의 이웃 리스트에 복제된 이웃 추가
+      cloned.get(currentNode).neighbors.push(cloned.get(neighbor));
+    }
+  }
+
+  return cloned.get(node);
+};