Merge branch 'main' of https://github.com/printjin-gmailcom/Dalle_Code-Leetcode_Study

Author: printjin-gmailcom

clone-graph/YoungSeok-Choi.java

@@ -0,0 +1,86 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+// 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 {
+    public Map<Node, Node> nMap = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null)
+            return null;
+
+        if (nMap.containsKey(node)) {
+            return nMap.get(node);
+        }
+
+        Node clone = new Node(node.val);
+        nMap.put(node, clone);
+
+        for (Node nei : node.neighbors) {
+            clone.neighbors.add(cloneGraph(nei));
+        }
+
+        return clone;
+    }
+}
+
+class WrongSolution {
+    public Node graph;
+    public Map<Node, Node> nMap = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null)
+            return null;
+
+        graph = new Node(node.val);
+        nMap.put(node, graph);
+
+        // print(graph);
+
+        return clone(node, graph);
+    }
+
+    public Node clone(Node node, Node cur) {
+        for (int i = 0; i < node.neighbors.size(); i++) {
+            Node adj = node.neighbors.get(i);
+
+            if (nMap.containsKey(adj)) {
+                return nMap.get(adj);
+            }
+
+            nMap.put(adj, new Node(adj.val));
+            cur.neighbors.add(nMap.get(adj));
+            clone(adj, nMap.get(adj));
+        }
+
+        return cur;
+    }
+
+    public void print(Node node) {
+        System.out.println("visit " + node.val);
+
+        for (int i = 0; i < node.neighbors.size(); i++) {
+            Node adj = node.neighbors.get(i);
+            System.out.println("nei " + adj.val);
+            print(adj);
+        }
+    }
+}

clone-graph/byol-han.js

@@ -0,0 +1,37 @@
+/**
+ * https://leetcode.com/problems/clone-graph/
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ * 시간 복잡도: O(N) — 노드 수만큼 순회
+ * 공간 복잡도: O(N) — visited 맵과 재귀 호출 스택
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) return null;
+
+  const visited = new Map();
+
+  const dfs = (n) => {
+    if (visited.has(n)) {
+      return visited.get(n);
+    }
+
+    const clone = new Node(n.val);
+    visited.set(n, clone);
+
+    for (let neighbor of n.neighbors) {
+      clone.neighbors.push(dfs(neighbor));
+    }
+
+    return clone;
+  };
+
+  return dfs(node);
+};

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);
+};

clone-graph/krokerdile.js

@@ -0,0 +1,27 @@
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function(node) {
+    if (!node) return null;
+
+    const visited = new Map(); // 원본 노드 -> 복제 노드
+
+    function dfs(curr) {
+        if (visited.has(curr)) {
+            return visited.get(curr); // 이미 복제한 경우
+        }
+
+        const copy = new _Node(curr.val);
+        visited.set(curr, copy); // 복제한 노드 저장
+
+        for (const neighbor of curr.neighbors) {
+            copy.neighbors.push(dfs(neighbor)); // 이웃도 재귀적으로 복사
+        }
+
+        return copy;
+    }
+
+    return dfs(node);
+};
+

clone-graph/lhc0506.js

@@ -0,0 +1,38 @@
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function(node) {
+  if (!node) return null;
+
+  const stack = [node];
+  const map = new Map();
+
+  map.set(node.val, new _Node(node.val));
+
+  while (stack.length > 0) {
+      const currentNode = stack.pop();
+
+      for (const neighbor of currentNode.neighbors) {
+          if (!map.has(neighbor.val)) {
+              map.set(neighbor.val, new Node(neighbor.val));
+              stack.push(neighbor);
+          }
+          map.get(currentNode.val).neighbors.push(map.get(neighbor.val));
+      }
+
+  }
+  return map.get(node.val);
+};
+
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)

clone-graph/moonjonghoo.js

@@ -0,0 +1,36 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) return null;
+
+  const visited = new Map();
+
+  const dfs = (currNode) => {
+    if (visited.has(currNode)) {
+      return visited.get(currNode);
+    }
+
+    // 노드 복사
+    const clone = new Node(currNode.val);
+    visited.set(currNode, clone);
+
+    // 이웃 노드들도 복사해서 연결
+    for (let neighbor of currNode.neighbors) {
+      clone.neighbors.push(dfs(neighbor));
+    }
+
+    return clone;
+  };
+
+  return dfs(node);
+};

clone-graph/sejineer.py

@@ -0,0 +1,23 @@
+"""
+시간 복잡도: O(V + E) V: 노드 개수, E: 간선 개수
+공간 복잡도: O(V)
+"""
+from collections import deque
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return
+        
+        clone = Node(node.val)
+        vis = {node: clone}
+        queue = deque([node])
+
+        while queue:
+            cur = queue.popleft()
+            for nxt in cur.neighbors:
+                if nxt not in vis:
+                    vis[nxt] = Node(nxt.val)
+                    queue.append(nxt)
+                vis[cur].neighbors.append(vis[nxt])
+        return clone

clone-graph/sora0319.java

@@ -0,0 +1,41 @@
+/*
+// 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 {
+    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 neighbor : node.neighbors) {
+            clone.neighbors.add(cloneGraph(neighbor));
+        }
+
+        return clone;
+    }
+}
+

clone-graph/uraflower.js

@@ -0,0 +1,31 @@
+// Definition for a _Node.
+function _Node(val, neighbors) {
+    this.val = val === undefined ? 0 : val;
+    this.neighbors = neighbors === undefined ? [] : neighbors;
+};
+
+/**
+ * 그래프를 깊은 복사하여 반환하는 함수
+ * @param {_Node} node
+ * @return {_Node}
+ */
+const cloneGraph = function (node) {
+    if (!node) return null;
+
+    function dfs(node, visited) {
+        const current = new _Node(node.val);
+        visited.set(node, current);
+
+        node.neighbors.forEach((neighbor) => {
+            const clonedNeighbor = visited.has(neighbor) ? visited.get(neighbor) : dfs(neighbor, visited);
+            current.neighbors.push(clonedNeighbor);
+        });
+
+        return current;
+    }
+
+    return dfs(node, new Map()); // visited: 원본 노드를 key, 클론한 노드를 value로 하는 맵
+};
+
+// 시간복잡도: O(V + E) (모든 노드와 간선을 한 번씩 순회)
+// 공간복잡도: O(V) (visited 맵 + 재귀 호출 스택)