Merge branch 'DaleStudy:main' into main

Author: Lustellz

clone-graph/Geegong.java

@@ -0,0 +1,84 @@
+import java.util.*;
+
+/*
+// 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;
+    }
+}
+*/
+public class Geegong {
+
+    /**
+     * dfs 방식으로 풀이
+     * visited 로 memoization 하여 방문해서 복사가 된 노드들을 저장
+     * 한번 방문했던 노드를 neighbors 탐색을 통해 또 방문하게 되면 visited 에서 꺼내서 return 하도록 한다.
+     *
+     * time complexity : O(2N) -> O(N)
+     * space complexity : O(N)
+     * @param node
+     * @return
+     */
+    public Node cloneGraph(Node node) {
+        // node에 진입한 순간에 바로 visited 에 넣어서 cloned 된 node 들을 집어넣도록 관리
+        Map<Integer, Node> visited = new HashMap<>();
+
+        if (node == null) {
+            return null;
+        }
+
+        Node result = cloneDeeply(node, visited);
+        return result;
+    }
+
+    public Node cloneDeeply(Node origin, Map<Integer, Node> visited) {
+
+        // visited 에는 cloned 된 node 들을 저장하고 있어 한번 방문했던 노드라면 복사한 노드를 리턴한다.
+        if (visited.containsKey(origin.val)) {
+            return visited.get(origin.val);
+        }
+
+        Node clonedTarget = new Node(origin.val);
+        visited.put(origin.val, clonedTarget);
+
+        for (Node neighbor : origin.neighbors) {
+            Node clonedNeighbor = cloneDeeply(neighbor, visited);
+            clonedTarget.neighbors.add(clonedNeighbor);
+        }
+
+        return clonedTarget;
+    }
+
+
+    // 이미 다른 분들이 Node 클래스를 많이 만들어놓으셔서.. 개인 클래스 안에 이너 클래스로 Node 만듬
+    public static 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;
+        }
+    }
+}
+
+

clone-graph/delight010.swift

@@ -0,0 +1,34 @@
+class Solution {
+    // Time O(V+E)
+    // Space O(V)
+    func cloneGraph(_ node: Node?) -> Node? {
+        guard let node = node else { return nil }
+        
+        var visited: [Int: Node] = [:]
+        var queue: [Node] = []
+        
+        let firstNode = Node(node.val)
+        visited[node.val] = firstNode
+        
+        queue.append(node)
+        
+        while !queue.isEmpty {
+            let currentNode = queue.removeFirst()
+            
+            for neighbor in currentNode.neighbors {
+                guard let neighbor = neighbor else { continue }
+                
+                if let clonedNeighbor = visited[neighbor.val] {
+                    visited[currentNode.val]!.neighbors.append(clonedNeighbor)
+                } else {
+                    visited[neighbor.val] = Node(neighbor.val)
+                    visited[currentNode.val]!.neighbors.append(visited[neighbor.val])
+                    queue.append(neighbor)
+                }
+            }
+        }
+        
+        return firstNode
+    }
+}
+ 

clone-graph/hu6r1s.py

@@ -0,0 +1,28 @@
+"""
+# 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 []
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        visited = [None] * 101
+        
+        def dfs(n):
+            if visited[n.val] is not None:
+                return visited[n.val]
+            
+            copy = Node(n.val, [])
+            visited[n.val] = copy
+            
+            for nei in n.neighbors:
+                copy.neighbors.append(dfs(nei))
+            return copy
+
+        return dfs(node)

clone-graph/hyer0705.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 {
+  if (!node) return null;
+
+  const cloned = new Map<number, _Node>();
+
+  const queue: _Node[] = [];
+
+  const copied = new _Node(node.val);
+  cloned.set(node.val, copied);
+
+  queue.push(node);
+
+  let pointer = 0;
+
+  while (pointer < queue.length) {
+    const current = queue[pointer++];
+
+    const copiedNode = cloned.get(current.val)!;
+
+    for (const neighbor of current.neighbors) {
+      if (!cloned.has(neighbor.val)) {
+        const copiedNeighbor = new _Node(neighbor.val);
+        cloned.set(neighbor.val, copiedNeighbor);
+
+        queue.push(neighbor);
+      }
+      copiedNode.neighbors.push(cloned.get(neighbor.val)!);
+    }
+  }
+
+  return copied;
+}

clone-graph/njngwn.java

@@ -0,0 +1,40 @@
+/*
+// 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 {
+    HashMap<Node, Node> nodeMap = new HashMap<>(); // key: original Node, value: copied Node
+
+    public Node cloneGraph(Node node) {
+        if (node == null) return null;
+
+        if (nodeMap.containsKey(node)) {
+            return nodeMap.get(node);
+        }
+
+        Node newNode = new Node(node.val);
+        nodeMap.put(node, newNode);
+
+        for (Node neighborNode : node.neighbors) {
+            newNode.neighbors.add(cloneGraph(neighborNode));
+        }
+
+        return newNode;
+    }
+}

clone-graph/sonjh1217.swift

@@ -0,0 +1,39 @@
+/**
+ * Definition for a Node.
+ * public class Node {
+ *     public var val: Int
+ *     public var neighbors: [Node?]
+ *     public init(_ val: Int) {
+ *         self.val = val
+ *         self.neighbors = []
+ *     }
+ * }
+ */
+
+class Solution {
+    // O(V+E) time / O(V) space
+    func cloneGraph(_ node: Node?) -> Node? {
+        guard let node = node else {
+            return nil
+        }
+        var newNodeByVal = [Int: Node]()
+        return copy(node: node, newNodeByVal: &newNodeByVal)
+    }
+    
+    func copy(node: Node, newNodeByVal: inout [Int: Node]) -> Node {
+        if let node = newNodeByVal[node.val] {
+            return node
+        }
+        var newNode = Node(node.val)
+        newNodeByVal[node.val] = newNode
+        
+        for neighbor in node.neighbors {
+            guard let neighbor = neighbor else {
+                continue
+            }
+            let newNeighbor = copy(node: neighbor, newNodeByVal: &newNodeByVal)
+            newNode.neighbors.append(newNeighbor)
+        }
+        return newNode
+    }
+}

clone-graph/yhkee0404.scala

@@ -0,0 +1,33 @@
+import scala.collection.mutable.ListBuffer
+
+/**
+ * Definition for a Node.
+ * class Node(var _value: Int) {
+ *   var value: Int = _value
+ *   var neighbors: List[Node] = List()
+ * }
+ */
+
+object Solution {
+    def cloneGraph(graph: Node): Node = {
+        if (graph == null) {
+            return null
+        }
+        val dp = Array.fill[Node](101)(null)
+        cloneGraph(dp, graph)
+    }
+    def cloneGraph(dp: Array[Node], graph: Node): Node = {
+        if (dp(graph.value) != null) {
+            return dp(graph.value)
+        }
+        val u = Node(graph.value)
+        dp(graph.value) = u
+        val neighbors = ListBuffer[Node]()
+        graph.neighbors
+                .foreach {
+                    neighbors += cloneGraph(dp, _)
+                }
+        u.neighbors ++= neighbors
+        u
+    }
+}

linked-list-cycle/hyer0705.ts

@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function hasCycle(head: ListNode | null): boolean {
+  if (!head || !head.next) return false;
+
+  let slow = head;
+  let fast = head;
+  while (fast && fast.next) {
+    slow = slow.next;
+    fast = fast.next.next;
+    if (slow === fast) return true;
+  }
+
+  return false;
+}