Merge branch 'DaleStudy:main' into main

Author: Sunjae95

.github/labeler.yml

@@ -18,11 +18,21 @@ java:
       - any-glob-to-any-file:
           - "**/*.java"
 
+c:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.c"
+
 c++:
   - changed-files:
       - any-glob-to-any-file:
           - "**/*.cpp"
 
+c#:
+  - changed-files:
+      - any-glob-to-any-file:
+          - "**/*.cs"
+
 swift:
   - changed-files:
       - any-glob-to-any-file:

.github/workflows/integration.yaml

@@ -16,7 +16,7 @@ jobs:
           files=$(git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.sha }})
           success=true
           for file in $files; do
-            if [ "$(tail -c 1 $file | wc -l)" -eq 0 ]; then
+            if [ -s "$file" ] && [ "$(tail -c 1 $file | wc -l)" -eq 0 ]; then
               echo "- $file" >> $GITHUB_STEP_SUMMARY
               success=false
             fi

clone-graph/EGON.py

@@ -0,0 +1,58 @@
+from typing import Optional, TypeVar
+from unittest import TestCase, main
+
+
+# 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]:
+        return self.solve(node)
+
+    """
+    Runtime: 42 ms (Beats 45.48%)
+    Time Complexity: O(n)
+
+    Memory: 17.04 (Beats 8.15%)
+    Space Complexity: O(n), upper bound
+    """
+    def solve(self, node: Optional[Node]) -> Optional[Node]:
+        clone_dict = {}
+        stack = [node]
+        visited = set()
+        while stack:
+            curr_node = stack.pop()
+            visited.add(curr_node.val)
+            if curr_node.val not in clone_dict:
+                clone_dict[curr_node.val] = Node(val=curr_node.val)
+
+            for neighbor in curr_node.neighbors:
+                if neighbor.val not in clone_dict:
+                    clone_dict[neighbor.val] = Node(val=neighbor.val)
+
+                if neighbor.val not in visited:
+                    clone_dict[curr_node.val].neighbors.append(clone_dict[neighbor.val])
+                    clone_dict[neighbor.val].neighbors.append(clone_dict[curr_node.val])
+                    stack.append(neighbor)
+
+        return clone_dict[node.val]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        node_dict = {1: Node(1), 2: Node(2), 3: Node(3), 4: Node(4)}
+        node_dict[1].neighbors = [node_dict[2], node_dict[4]]
+        node_dict[2].neighbors = [node_dict[1], node_dict[3]]
+        node_dict[3].neighbors = [node_dict[2], node_dict[4]]
+        node_dict[4].neighbors = [node_dict[1], node_dict[3]]
+
+        Solution.cloneGraph(Solution(), node_dict[1])
+        self.assertTrue("RUN")
+
+
+if __name__ == '__main__':
+    main()

clone-graph/TonyKim9401.java

@@ -0,0 +1,19 @@
+// TC: O(n)
+// -> visit all elements once for each to clone them
+// SC: O(n)
+// -> all elements are stored in HashMap and values are limited maximum 2
+class Solution {
+    private Map<Integer, Node> map = new HashMap<>();
+    public Node cloneGraph(Node node) {
+        if (node == null) return null;
+        if (map.containsKey(node.val)) return map.get(node.val);
+
+        Node clone = new Node(node.val);
+        map.put(clone.val, clone);
+
+        for (Node neighbor : node.neighbors) {
+            clone.neighbors.add(cloneGraph(neighbor));
+        }
+        return clone;
+    }
+}

clone-graph/flynn.cpp

@@ -0,0 +1,67 @@
+/**
+ * 풀이
+ * - BFS와 해시맵을 사용하여 풀이합니다
+ * 
+ * Big O
+ * - N: 주어진 노드의 개수
+ * - E: 주어진 노드의 간선의 개수
+ * 
+ * - Time complexity: O(E)
+ *   - 한 Node에서 다른 Node로 향하는 모든 edge를 두번씩 탐색합니다 (두 방향으로 연결되어 있기 때문)
+ * - Space complexity: O(N) 
+ *   - 해시맵에 최대 N개의 노드를 저장합니다
+ */
+
+/*
+// 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 == nullptr) return nullptr;
+
+        unordered_map<Node*, Node*> node_map;
+        node_map[node] = new Node(node->val);
+
+        queue<Node*> q;
+        q.push(node);
+
+        while (!q.empty()) {
+            Node* p = q.front();
+            q.pop();
+
+            for (Node* neighbor : p->neighbors) {
+                // 방문한 적이 없는 노드일 경우
+                if (node_map.find(neighbor) == node_map.end()) {
+                    // node_map에 새로운 노드를 복제하여 추가
+                    node_map[neighbor] = new Node(neighbor->val);
+
+                    // 큐에 추가
+                    q.push(neighbor);
+                }
+
+                node_map[p]->neighbors.push_back(node_map[neighbor]);
+            }
+        }
+
+        return node_map[node];
+    }
+};

clone-graph/jdalma.kt

@@ -0,0 +1,94 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import java.lang.RuntimeException
+import java.util.ArrayDeque
+import java.util.Queue
+
+class `clone-graph` {
+
+    data class Node(var `val`: Int) {
+        var neighbors: ArrayList<Node?> = ArrayList()
+    }
+
+    fun cloneGraph(node: Node?): Node? {
+        if (node == null) return null
+
+        return usingBFS(node)
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDFS(node: Node): Node {
+
+        fun dfs(node: Node, nodes: MutableMap<Int, Node>): Node {
+            nodes[node.`val`]?.let {
+                return it
+            }
+            val copy = Node(node.`val`)
+            nodes[node.`val`] = copy
+
+            for (near in node.neighbors.filterNotNull()) {
+                copy.neighbors.add(dfs(near, nodes))
+            }
+
+            return copy
+        }
+        return dfs(node, mutableMapOf())
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingBFS(node: Node): Node {
+        val nodes = mutableMapOf<Int, Node>().apply {
+            this[node.`val`] = Node(node.`val`)
+        }
+        val queue: Queue<Node> = ArrayDeque<Node>().apply {
+            this.offer(node)
+        }
+
+        while (queue.isNotEmpty()) {
+            val now = queue.poll()
+            val copy = nodes[now.`val`] ?: throw RuntimeException()
+            for (near in now.neighbors.filterNotNull()) {
+                if (!nodes.containsKey(near.`val`)) {
+                    nodes[near.`val`] = Node(near.`val`)
+                    queue.add(near)
+                }
+                copy.neighbors.add(nodes[near.`val`])
+            }
+        }
+        return nodes[node.`val`] ?: Node(node.`val`)
+    }
+
+    private fun fixture(): Node {
+        val one = Node(1)
+        val two = Node(2)
+        val three = Node(3)
+        val four = Node(4)
+
+        one.neighbors.add(two)
+        one.neighbors.add(four)
+        two.neighbors.add(one)
+        two.neighbors.add(three)
+        three.neighbors.add(two)
+        three.neighbors.add(four)
+        four.neighbors.add(one)
+        four.neighbors.add(three)
+
+        return one
+    }
+
+    @Test
+    fun `입력받은 노드의 깊은 복사본을 반환한다`() {
+        val actualNode = fixture()
+        val expectNode = cloneGraph(actualNode)
+        actualNode shouldBe expectNode
+
+        actualNode.`val` = 9999
+        expectNode!!.`val` shouldBe 1
+    }
+}

longest-common-subsequence/EGON.py

@@ -0,0 +1,44 @@
+from unittest import TestCase, main
+
+
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        return self.solve_dp(text1, text2)
+
+    """
+    Runtime: 441 ms (Beats 85.60%)
+    Time Complexity: O(m * n)
+        - text1, text2의 길이를 각각 m, n이라 하면 이중 for문 조회에 O(m * n)
+        - i. dp 배열 값 갱신에서 기존값 +1에 O(1)
+        - ii. dp 배열 값 갱신에서 2개 항에 대한 max 연산에 O(2), upper bound
+        > O(m * n) * O(2) ~= O(m * n) 
+
+    Memory: 41.81 (Beats 55.93%)
+    Space Complexity: O(m * n)
+        > row의 길이가 n이가 col의 길이가 m인 2차원 배열 dp 사용에 O(m * n)
+    """
+    def solve_dp(self, text1: str, text2: str) -> int:
+        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
+        for idx1 in range(len(text1)):
+            for idx2 in range(len(text2)):
+                if text1[idx1] == text2[idx2]:
+                    dp[idx1 + 1][idx2 + 1] = dp[idx1][idx2] + 1
+                else:
+                    dp[idx1 + 1][idx2 + 1] = max(dp[idx1 + 1][idx2], dp[idx1][idx2 + 1])
+
+        return dp[-1][-1]
+
+
+class _LeetCodeTestCases(TestCase):
+    def test_1(self):
+        text1 = "abcde"
+        text2 = "ace"
+        output = 3
+        self.assertEqual(
+            Solution().longestCommonSubsequence(text1, text2),
+            output
+        )
+
+
+if __name__ == '__main__':
+    main()

longest-common-subsequence/TonyKim9401.java

@@ -0,0 +1,23 @@
+// TC: O(n * m)
+// the length of text1 by the length of text2
+// SC: O(n)
+// both size of text1 and text2 can be the size of dp
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int[] dp = new int[text2.length()];
+        int output = 0;
+
+        for (char c : text1.toCharArray()) {
+            int curLength = 0;
+
+            for (int i = 0; i < dp.length; i++) {
+                if (curLength < dp[i]) curLength = dp[i];
+                else if (c == text2.charAt(i)) {
+                    dp[i] = curLength + 1;
+                    output = Math.max(output, dp[i]);
+                }
+            }
+        }
+        return output;
+    }
+}