Merge branch 'DaleStudy:main' into main

Author: jdy8739

best-time-to-buy-and-sell-stock/thispath98.py

@@ -0,0 +1,12 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minimum = prices[0]
+        answer = 0
+        for i in range(1, len(prices)):
+            if minimum > prices[i]:
+                minimum = prices[i]
+            else:
+                diff = prices[i] - minimum
+                if answer < diff:
+                    answer = diff
+        return answer

clone-graph/Chaedie.py

@@ -0,0 +1,32 @@
+"""
+한번에 풀지 못해 다시 풀어볼 예정입니다.
+
+Solution:
+    1) oldToNew 라는 dict 를 만들어 무한루프를 방지합니다.
+    2) newNode = Node(node.val), newNode.neighbors.append(dfs(nei)) 를 통해 clone을 구현합니다.
+
+정점 V, 간선 E
+Time: O(V + E)
+Space: O(V + E)
+"""
+
+
+class Solution:
+    def cloneGraph(self, root: Optional["Node"]) -> Optional["Node"]:
+        if not root:
+            return None
+        oldToNew = {}
+
+        def dfs(node):
+            if node in oldToNew:
+                return oldToNew[node]
+
+            newNode = Node(node.val)
+            oldToNew[node] = newNode
+
+            for nei in node.neighbors:
+                newNode.neighbors.append(dfs(nei))
+
+            return newNode
+
+        return dfs(root)

clone-graph/EcoFriendlyAppleSu.kt

@@ -0,0 +1,47 @@
+package leetcode_study
+
+/*
+* Graph Node 복사 문제
+* queue를 사용해 문제 해결
+* 새로 생성한 Node에 대해 방문처리를 하지 않을 경우 무한 Loop에 빠지게됨 -> 각 노드가 양방향을 가리키고 있기 때문.
+* 따라서, Map 자료구조를 사용해 Map<기존 Node, 복사 Node>의 모습으로 Key-Value 쌍으로 방문처리를 표현
+*
+* 시간 복잡도: O(n)
+* -> graph의 Node를 한 번씩 방문하여 복사하는 과정: O(n)
+* 공간 복잡도:
+* -> 복사된 Node를 매핑하는 Map 자료구조의 크기: O(n)
+* -> BFS를 사용한 queue size: O(n)
+* -> 새로 생성된 Node의 neighbor list: O(n)
+* */
+fun cloneGraph(node: Node?): Node? {
+    if (node == null) return null
+    if (node.neighbors.isEmpty()) return Node(1)
+
+    // Map< 기존 Node, 복사 Node>
+    val nodeMap = mutableMapOf<Node, Node>()
+
+    val queue = ArrayDeque<Node>()
+    queue.add(node)
+    nodeMap[node] = Node(node.`val`)
+
+    while (queue.isNotEmpty()) {
+        val current = queue.removeFirst()
+        val clonedNode = nodeMap[current]!! // 현재 노드의 복제본
+
+        for (neighbor in current.neighbors) {
+            if (neighbor == null) continue
+
+            // 해당 이웃이 아직 복사되지 않았다면 복사하여 맵에 저장하고 큐에 추가
+            if (!nodeMap.containsKey(neighbor)) {
+                nodeMap[neighbor] = Node(neighbor.`val`)
+                queue.add(neighbor)
+            }
+
+            // 복제된 현재 노드의 이웃 리스트에 복제된 이웃 노드를 추가
+            // 양방향을 따질 필요 없이 내부 neighbor node list에 모든 노드가 있음
+            clonedNode.neighbors.add(nodeMap[neighbor])
+        }
+    }
+    return nodeMap[node]
+}
+

clone-graph/Jeehay28.js

@@ -0,0 +1,68 @@
+/**
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+
+// BFS approach
+// Time Complexity: O(N + E), where N is the number of nodes and E is the number of edges.
+// Space Complexity: O(N), due to the clones map and additional storage (queue for BFS, recursion stack for DFS).
+
+var cloneGraph = function (node) {
+  if (!node) {
+    return null;
+  }
+  let clone = new Node(node.val);
+  let clones = new Map();
+  clones.set(node, clone);
+  let queue = [node];
+  while (queue.length > 0) {
+    node = queue.shift();
+    for (const neighbor of node.neighbors) {
+      if (!clones.get(neighbor)) {
+        const temp = new Node(neighbor.val);
+        clones.set(neighbor, temp);
+        queue.push(neighbor);
+      }
+      clones.get(node).neighbors.push(clones.get(neighbor));
+    }
+  }
+
+  return clone;
+};
+
+// DFS approach
+// Time Complexity: O(N + E), where N is the number of nodes and E is the number of edges.
+// Space Complexity: O(N), due to the clones map and the recursion stack.
+
+var cloneGraph = function (node) {
+  if (!node) {
+    return null;
+  }
+
+  let clones = new Map();
+
+  const dfs = (node) => {
+    if (clones.has(node)) {
+      return clones.get(node);
+    }
+    let clone = new Node(node.val);
+    clones.set(node, clone);
+
+    for (neighbor of node.neighbors) {
+      clone.neighbors.push(dfs(neighbor));
+    }
+
+    return clone;
+  };
+
+  return dfs(node);
+};
+

clone-graph/KwonNayeon.py

@@ -0,0 +1,63 @@
+"""
+Constraints:
+- The number of nodes in the graph is in the range [0, 100].
+- 1 <= Node.val <= 100
+- Node.val is unique for each node.
+- There are no repeated edges and no self-loops in the graph.
+- The Graph is connected and all nodes can be visited starting from the given node.
+
+Shallow Copy (얕은 복사):
+- 노드 자체는 새로운 메모리에 복사
+- 하지만 neighbors는 원본 노드의 neighbors를 그대로 참조
+예시) 원본 Node1이 Node2를 neighbor로 가질 때
+   복사한 CopyNode1은 새로운 노드지만
+   CopyNode1의 neighbor는 원본의 Node2를 그대로 가리킴
+
+Deep Copy (깊은 복사):
+- 노드는 새로운 메모리에 복사
+- neighbors도 모두 새로운 노드로 복사해서 연결
+예시) 원본 Node1이 Node2를 neighbor로 가질 때
+   CopyNode1도 새로운 노드이고
+   CopyNode1의 neighbor도 새로 만든 CopyNode2를 가리킴
+
+Time Complexity: O(N + E)
+- N: 노드의 개수
+- E: 엣지의 개수
+- 모든 노드와 엣지를 한 번씩 방문
+
+Space Complexity: O(N)
+- N: 노드의 개수
+- dictionary와 재귀 호출 스택 공간
+
+# 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: Optional['Node']) -> Optional['Node']:
+       if not node:
+           return None
+           
+       dict = {}
+       
+       def dfs(node):
+           if node.val in dict:  # 이미 복사한 노드라면
+               return dict[node.val]  # 해당 복사본 반환
+           
+           # 새로운 노드 생성
+           copy = Node(node.val)
+           dict[node.val] = copy  # dictionary에 기록
+           
+           # 각 neighbor에 대해서도 같은 과정 수행
+           for neighbor in node.neighbors:
+               copy.neighbors.append(dfs(neighbor))
+               
+           return copy
+       
+       return dfs(node)
+

clone-graph/dusunax.py

@@ -0,0 +1,35 @@
+'''
+# 133. Clone Graph
+This is the problem for copying nodes, which helps you understand the concept of referencing a node & copying the node (creating a new node from the existing one).
+
+👉 Perform recursion DFS with the correct escape condition and handling of NoneType.
+'''
+
+"""
+# 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 node is None:
+            return None
+            
+        visited = {}
+        
+        def DFS(currNode):
+            if currNode.val in visited:
+                return visited[currNode.val]
+
+            copiedNode = Node(currNode.val)
+            visited[currNode.val] = copiedNode
+
+            for neighbor in currNode.neighbors:
+                copiedNode.neighbors.append(DFS(neighbor))
+
+            return copiedNode
+
+        return DFS(node)

clone-graph/ekgns33.java

@@ -0,0 +1,42 @@
+/*
+// 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 Node cloneGraph(Node node) {
+    Map<Integer, Node> nodeMap = new HashMap<>();
+    if(node == null) return null;
+    boolean[] visited = new boolean[101];
+    dfsHelper(nodeMap, node, visited);
+    return nodeMap.get(1);
+  }
+
+  private void dfsHelper(Map<Integer, Node> map, Node node, boolean[] visited) {
+    if(!map.containsKey(node.val)) {
+      map.put(node.val, new Node(node.val));
+    }
+    visited[node.val] = true;
+    Node cur = map.get(node.val);
+    for(Node adjacent : node.neighbors) {
+      map.putIfAbsent(adjacent.val, new Node(adjacent.val));
+      cur.neighbors.add(map.get(adjacent.val));
+      if(!visited[adjacent.val]) dfsHelper(map, adjacent, visited);
+    }
+  }
+}

clone-graph/forest000014.java

@@ -0,0 +1,77 @@
+/*
+# Time Complexity: O(n * e), where e is the maximum number of edges of a node
+  - 전체 node를 순회하면서, 그 이웃에 해당하는 복제본을 생성해서 복제본끼리 연결해준다.
+  - 단, 중복 방문을 막기 위해, 복제본이 이미 이웃 복제본을 가지고 있는지 확인한다. 이 과정에서 O(e)만큼의 List 순회를 한다.
+
+# Space Complexity: O(n)
+  - 전체 Node 만큼의 메모리가 필요하다.
+(Space Complexity를 계산하기 애매한 측면이 있네요. 저는 지금까지 출력은 space complexity에 포함하지 않고 계산했었는데, 그 이유는 "어떤 알고리즘을 구현하든 출력은 동일하기 때문"인데요. 이 문제의 경우에 출력은 Node 하나이지만, 실제로는 Node 전체만큼의 메모리를 반드시 생성해야 한다는 특수성이 있습니다. 그래서 "어떻게 구현하든 동일하게 사용해야만 하는 메모리는 Space Complexity에서 배제한다" 라는 논리로만 보자면 O(1)일 것 같고, "출력을 제외한 메모리 사용은 Space Complexity에 포함한다" 라는 논리대로라면 O(n)인 것 같습니다.)
+
+
+전체 노드를 DFS로 순회하면서 이웃 노드의 복제본을 생성하여 현재 노드의 복제본과 연결을 맺어줍니다.
+다만, 중복 방문을 막기 위해, 복제본이 이미 이웃 복제본을 가지고 있는지 확인한다.
+또한 순환 참조(cycle 구조)를 막기 위해서, 복제본 노드를 생성시 단순히 new 키워드를 사용하지 않고, 별도의 map을 통해 싱글톤으로 생성한다. (각 노드의 val은 distinct하다는 점을 이용)
+
+
+// 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<Integer, Node> map = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+
+        Node newNode = createNode(node.val);
+        dfs(node);
+
+        return newNode;
+    }
+
+    public Node createNode(int val) {
+        if (!map.containsKey(val)) {
+            map.put(val, new Node(val));
+        }
+        return map.get(val);
+    }
+
+    public void dfs(Node oldNode) {
+        Node newNode = map.get(oldNode.val);
+
+        for (Node oldNeighbor : oldNode.neighbors) {
+            boolean hasIt = false;
+            for (Node newNeighbor : newNode.neighbors) {
+                if (newNeighbor.val == oldNeighbor.val) {
+                    hasIt = true;
+                    break;
+                }
+            }
+
+            if (!hasIt) {
+                Node newNeighbor = createNode(oldNeighbor.val);
+                newNode.neighbors.add(newNeighbor);
+                newNeighbor.neighbors.add(newNode);
+                dfs(oldNeighbor);
+            }
+        }
+    }
+}