Merge branch 'DaleStudy:main' into main

Author: HYUNAHKO

binary-tree-level-order-traversal/chjung99.java

@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> answer = new ArrayList<>();
+        Deque<Pair> queue = new ArrayDeque<>();
+        int[] visit = new int[2000];
+        if (root != null){
+            queue.add(new Pair(root, 0));
+        }
+
+        while (!queue.isEmpty()) {
+            Pair cur = queue.poll();
+            // System.out.println(cur.node.val+ " depth="+cur.depth);
+            if (visit[cur.depth] == 0){
+                answer.add(new ArrayList<>());
+                visit[cur.depth] = 1;
+            }
+            List<Integer> ls = answer.get(cur.depth);
+            ls.add(cur.node.val);
+
+            if (cur.node.left != null) queue.add(new Pair(cur.node.left, cur.depth + 1));
+            if (cur.node.right != null) queue.add(new Pair(cur.node.right, cur.depth + 1));
+        }
+        return answer;
+    }
+    class Pair{
+        TreeNode node;
+        int depth;
+
+        public Pair(TreeNode node, int depth){
+            this.node = node;
+            this.depth = depth;
+        }
+    }
+}
+
+

clone-graph/8804who.py

@@ -0,0 +1,33 @@
+"""
+# 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 
+        visited = {}
+        new_node = Node()
+        def dfs(original_node, new_node):
+            if original_node.val in visited:
+                return
+            visited[original_node.val] = new_node
+            new_node.val = original_node.val
+            new_node.neighbors = []
+
+            for neighbor in original_node.neighbors:
+                new_node.neighbors.append(Node())
+                if neighbor.val not in visited:
+                    dfs(neighbor, new_node.neighbors[-1])
+                new_node.neighbors[-1] = visited[neighbor.val]
+        dfs(node, new_node)
+        return new_node
+    
+
+

clone-graph/Blossssom.ts

@@ -0,0 +1,80 @@
+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 visited = new Map<_Node, _Node>();
+
+  visited.set(node, new _Node(node.val));
+
+  const queue: _Node[] = [node];
+
+  while (queue.length > 0) {
+    const currentNode = queue.shift()!;
+
+    for (const n of currentNode?.neighbors) {
+      if (!visited.has(n)) {
+        visited.set(n, new _Node(n.val));
+        queue.push(n);
+      }
+
+      visited.get(currentNode)!.neighbors.push(visited.get(n)!);
+    }
+  }
+
+  return null;
+}
+
+// function cloneGraph(node: _Node | null): _Node | null {
+//   if (!node) {
+//     return null;
+//   }
+
+//   const checkMap = new Map<number, _Node>();
+
+//   function dfs(targetNode: _Node) {
+//     if (checkMap.has(targetNode.val)) {
+//       return checkMap.get(targetNode.val)!;
+//     }
+
+//     const newNode = new _Node(targetNode.val);
+//     checkMap.set(targetNode.val, newNode);
+
+//     for (const n of targetNode.neighbors) {
+//       newNode.neighbors.push(dfs(n));
+//     }
+
+//     return newNode;
+//   }
+
+//   const result = dfs(node);
+
+//   return result;
+// }
+
+const node1 = new _Node(1);
+const node2 = new _Node(2);
+const node3 = new _Node(3);
+const node4 = new _Node(4);
+
+node1.neighbors = [node2, node4];
+node2.neighbors = [node1, node3];
+node3.neighbors = [node2, node4];
+node4.neighbors = [node1, node3];
+
+cloneGraph(node1);
+
+
+

clone-graph/chjung99.java

@@ -0,0 +1,49 @@
+/*
+// 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) {
+        if (node == null) return node;
+        return deepCopy(node);
+    }
+
+    public Node deepCopy(Node node) {
+        Deque<Node> deque = new ArrayDeque<>();
+        Node root = new Node(node.val, new ArrayList<>());
+        Map<Integer, Node> visit = new HashMap<>();
+
+        visit.put(1, root);
+        deque.add(node);
+
+        while (!deque.isEmpty()) {
+            Node cur = deque.poll();
+            for (Node next: cur.neighbors) {
+                if (!visit.containsKey(next.val)){
+                    visit.put(next.val, new Node(next.val, new ArrayList<>()));
+                    deque.add(next);
+                }
+                visit.get(cur.val).neighbors.add(visit.get(next.val));
+            }
+        }
+        return root;
+    }
+}
+
+

clone-graph/haxr369.java

@@ -0,0 +1,90 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Runtime: 25 ms (Beats 72.12%)
+ * Memory: 44.35 MB (Beats 34.32%)
+ * Space Complexity: O(N)
+ * - 모든 노드 저장 => O(N)
+ * - visited로 복사했던 노드 관리 => O(N)
+ * > O(N)
+ * Time Complexity: O(N)
+ * - 루트노드부터 모든 노드까지 한번씩 탐색 => O(N)
+ * > O(N)
+ * 
+ */
+
+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) {
+    if (node == null) {
+      return node;
+    }
+
+    if (node.neighbors == null) {
+      Node newNode = new Node(node.val, null);
+      return newNode;
+    } else if (node.neighbors.isEmpty()) {
+      Node newNode = new Node(node.val, new ArrayList<>());
+      return newNode;
+    }
+
+    Node[] visited = new Node[104];
+
+    Node ans = new Node(node.val, new ArrayList<>(node.neighbors));
+    visited[ans.val] = ans;
+    dfs(ans, visited);
+
+    return ans;
+  }
+
+  /**
+   * node의 리스트를 dfs로 변경해간다.
+   * 다만, 변경했던 노드는 다시 변경하지 않음
+   */
+  private void dfs(Node node, Node[] visited) {
+
+    List<Node> neighbors = node.neighbors; // 이전 것
+
+    List<Node> newNeighbors = new ArrayList<>(); // 새 껍질
+    // 하나씩 새걸로 바꾸자
+    for (Node n : neighbors) {
+      if (visited[n.val] != null) {
+        newNeighbors.add(visited[n.val]);
+        continue;
+      }
+      Node newN = new Node(n.val, new ArrayList<>(n.neighbors)); // 껍질 만들기
+      visited[newN.val] = newN;
+      dfs(newN, visited); //
+      newNeighbors.add(newN);
+    }
+    node.neighbors = newNeighbors; // 신규 리스트로 바꿔치기
+    // printNode(node);
+  }
+
+  private void printNode(Node node) {
+    System.out.print("val -> " + node.val);
+    System.out.println(" size -> " + node.neighbors.size());
+    node.neighbors.forEach(n -> System.out.print(n.val));
+    System.out.print('\n');
+  }
+}

clone-graph/imgolden77.py

@@ -0,0 +1,33 @@
+"""
+# 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
+        old_to_new = {}
+
+        def dfs(curr_node):
+            if curr_node in old_to_new:
+                return old_to_new[curr_node]
+            
+            copy = Node(curr_node.val)
+            old_to_new[curr_node] = copy
+
+            for neighbors in curr_node.neighbors:
+                copy.neighbors.append(dfs(neighbors))
+
+            return copy
+
+        return dfs(node)
+    
+    # O(N+E) time complexity where N is the number of nodes and E is the number of edges in the graph.
+    # O(N) space complexity for the hashmap and the recursion stack in the worst case.
+    
+

clone-graph/ys-han00.cpp

@@ -0,0 +1,52 @@
+/*
+// 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:
+    Node* cloneGraph(Node* node) {
+        if(!node)
+            return nullptr;
+        
+        
+        Node* clone = new Node(node->val);
+        map<Node*, Node*> clones;
+        queue<Node*> que;
+        
+        clones[node] = clone;
+        que.push(node);
+
+        while(!que.empty()) {
+            node = que.front();
+            que.pop();
+
+            for(auto neigh : node->neighbors) {
+                if(clones.find(neigh) == clones.end()) {
+                    que.push(neigh);
+                    clones[neigh] = new Node(neigh->val);
+                }
+                clones[node]->neighbors.push_back(clones[neigh]);
+            }
+        }
+
+        return clone;
+    }
+};
+