Merge branch 'DaleStudy:main' into main

Author: devyejin

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/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/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/jinvicky.java

@@ -0,0 +1,18 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    /**
+     * 문제에서 말하는 pos는 설명을 돕는 사이클 발생 위치이지 코드 상에서 사용하지 않는다.
+     */
+    public boolean hasCycle(ListNode head) {
+        Set<Integer> set = new HashSet<>();
+        while(head != null) {
+            // set에서 이미 존재하는 숫자가 있으면 바로 return true;
+            // set.add() 메서드는 추가 성공 시 true, 이미 존재하는 숫자면 추가하지 못하고 false를 반환한다.
+            if(!set.add(head.val)) return true;
+            head = head.next;
+        }
+        return false;
+    }
+}

longest-common-subsequence/Geegong.java

@@ -0,0 +1,82 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class Geegong {
+
+    /**
+     * LIS, LCS 와 연관지어서 풀이
+     * 1. 먼저 text1을 훑어보는데 text1에 중복되는 알파벳이 있을 수 있기에 각 캐릭터별로 인덱스들을 저장 (각 원소가 arrayList가 있는 배열)
+     * 2. text2 를 훑으면서 매칭되는 캐릭터들에 대해서만 1에서 저장된 인덱스들을 한 배열안에 나열
+     * -> 이떄 나열해서 넣을때마다 역순으로 집어넣는게 중요! (왜냐면 이 나열된 인덱스들을 가지고 LIS를 구할거라서)
+     * 3. 나열된 인덱스들의 값들을 가지고 LIS 를 구한다, 즉 이 LIS의 길이가 LCS 의 길이가 된다..!! (와우 신기)
+     * 그러나 leet code 에 돌렸을 때 runtime 이 영 좋지는 않음
+     *
+     * time complexity : O(M + N logN) => text2에 대해서 문자마다 바이너리서치가 수행됨
+     * space complexity : O(M+N)
+     * @param text1
+     * @param text2
+     * @return
+     */
+    public int longestCommonSubsequence(String text1, String text2) {
+        char[] chText1 = text1.toCharArray();
+        char[] chText2 = text2.toCharArray();
+
+        // text1만 각 원소 별로 char가 가지는 index를 array 로 갖는 배열을 생성
+        List<Integer>[] positionIndices = new List[26];
+        for (int index = 0; index<chText1.length; index++) {
+            if (positionIndices[chText1[index] - 'a'] == null) {
+                positionIndices[chText1[index] - 'a'] = new ArrayList();
+                positionIndices[chText1[index] - 'a'].add(index);
+            } else {
+                positionIndices[chText1[index] - 'a'].add(index);
+            }
+        }
+
+
+        // 여기서부터 LIS 를 구할것임
+        List<Integer> indices = new ArrayList<>();
+        for (int index=0; index<chText2.length; index++) {
+
+            char find = chText2[index];
+            if (positionIndices[find-'a'] != null && positionIndices[find-'a'].size() > 0) {
+                // 역순 (LIS 를 구하기 위해서 일부러 뒤집어 높음, 즉 각 char 별 LIS 를 구할것이기 때문에..)
+                // positionIndices 에서 구했던 값들을 그대로 addAll 한다면 오름차순이 되기때문에 정확한 LIS 를 구할 수 없다
+
+                indices.addAll(positionIndices[find-'a'].stream().sorted(Comparator.reverseOrder()).toList());
+            }
+        }
+
+        // find LIS
+        return findLIS(indices).size();
+    }
+
+    public List<Integer> findLIS(List<Integer> source) {
+        if (source.size() == 0) {
+            return source;
+        }
+
+        List<Integer> LISResult = new ArrayList<>();
+        for (int index=0; index<source.size(); index++) {
+            int target = source.get(index);
+            int insertionPosition = Collections.binarySearch(LISResult, target);
+            //Returns:
+            //the index of the search key, if it is contained in the list;
+            // otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the list:
+            if (insertionPosition < 0) {
+                insertionPosition = -insertionPosition - 1;
+            }
+
+            if (LISResult.size() == insertionPosition) {
+                LISResult.add(target);
+            } else {
+                LISResult.set(insertionPosition, target);
+            }
+        }
+
+        return LISResult;
+    }
+
+}
+

longest-common-subsequence/delight010.swift

@@ -0,0 +1,20 @@
+class Solution {
+    // Time (MN)
+    // Space (MN)
+    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
+        var dp = Array(repeating: Array(repeating: 0, count: text2.count + 1),
+                       count: text1.count + 1)
+        for (i, char1) in text1.enumerated() {
+            for (j, char2) in text2.enumerated() {
+                if char1 == char2 {
+                    dp[i + 1][j + 1] = dp[i][j] + 1
+                } else {
+                    dp[i + 1][j + 1] = max(dp[i + 1][j], dp[i][j + 1])
+                }
+            }
+        }
+        
+        return dp[text1.count][text2.count]
+    }
+}
+ 

longest-common-subsequence/hyer0705.ts

@@ -0,0 +1,18 @@
+function longestCommonSubsequence(text1: string, text2: string): number {
+  const m = text1.length;
+  const n = text2.length;
+
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (text1[i - 1] === text2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  return dp[m][n];
+}

longest-common-subsequence/yhkee0404.dart

@@ -0,0 +1,14 @@
+class Solution {
+  int longestCommonSubsequence(String text1, String text2) {
+    final dp = List.generate(
+                text1.length + 1,
+                (_) => List.filled(text2.length + 1, 0),
+            );
+    for (int i = 1; i <= text1.length; i++) {
+        for (int j = 1; j <= text2.length; j++) {
+            dp[i][j] = text1[i - 1] == text2[j - 1] ? dp[i - 1][j - 1] + 1 : max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp[text1.length][text2.length];
+  }
+}