Merge branch 'main' of https://github.com/sungjinwi/leetcode-study

Author: sungjinwi

3sum/sungjinwi.cpp

@@ -0,0 +1,60 @@
+/*
+    풀이 :
+        nums 배열을 정렬시킨 후 반복되는 값을 건너뛰며 두 포인터 기법을 사용한다
+        i포인터와 left, right 포인터의 값의 합이 0보다 작으면 left++, 크면 right--
+        0이면 ans에 저장하고 left++, right--하는 로직을 left < right인 동안 반복한다
+    
+    nums의 길이 N
+
+    TC : O(N^2)
+        외부 반복문 N * 내부 반복문 N
+    
+    SC : O(1) (ans 제외)
+        left, right, threeSum 3개의 변수만 사용한다
+*/
+
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> ans;
+        int left;
+        int right;
+        int threeSum;
+
+        sort(nums.begin(), nums.end());
+        for (int i = 0; i < nums.size() - 2; i++)
+        {
+            // i포인터 중복 제거
+            if (i > 0 && nums[i] == nums[i - 1])
+                continue ;
+
+            left = i + 1;
+            right = nums.size() - 1;
+            while (left < right)
+            {
+                threeSum = nums[i] + nums[left] + nums[right];
+                if (threeSum < 0)
+                    left++;
+                else if(threeSum > 0)
+                    right--;
+                else
+                {
+                    ans.push_back({nums[i], nums[left], nums[right]});
+                    // left포인터 중복 제거
+                    while (left < right && nums[left] == nums[left + 1])
+                        left++;
+                    // right 포인터 중복 제거
+                    while (left < right && nums[right] == nums[right - 1])
+                        right--;
+                    left++;
+                    right--;
+                }
+            }
+        }
+        return ans;
+    }
+};

best-time-to-buy-and-sell-stock/sungjinwi.cpp

@@ -0,0 +1,37 @@
+/*
+    풀이 :
+        현재의 price에 도달하기 전 가장 작은 price를 min_cur로 업데이트
+        price - min_cur가 저장되있는 max_profit보다 크면 값을 업데이트
+
+    prices의 개수 N
+
+    TC : O(N)
+
+    SC : O(1)
+*/
+
+
+#include <vector>
+using namespace std;
+
+class Solution {
+    public:
+        int maxProfit(vector<int>& prices) {
+            int min_cur = prices[0];
+            int max_profit = 0;
+
+            for (int& price : prices)
+            {
+                if (price < min_cur)
+                {
+                    min_cur = price;
+                    continue ;
+                }
+
+                int profit = price - min_cur;
+                if (profit > max_profit)
+                    max_profit = profit;
+            }
+            return max_profit;
+        }
+    };

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

@@ -0,0 +1,21 @@
+"""
+    TC : O(N)
+        for문 한 번 => O(N)
+
+    SC : O(1)
+        변수 3개 선언 이외에 추가적으로 사용하는 메모리 없으므로
+"""
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        buy = prices[0]
+        sell = prices[0]
+        for price in prices:
+            if price < buy:
+                buy = price
+                sell = price
+            if price > sell:
+                sell = price
+            max_profit = max(max_profit, sell - buy)
+        return max_profit

binary-tree-level-order-traversal/sungjinwi.py

@@ -0,0 +1,36 @@
+"""
+    풀이 :
+        level을 인자로 함께 넘겨서 level에 해당하는 인덱스에 append
+
+    node 개수 N
+
+    TC : O(N)
+        모든 node에 대해 dfs호출
+
+    SC : O(N)
+        dfs 함수 호출 스택이 노드 개수 N만큼
+"""
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        ans = []
+
+        def dfs(node: Optional[TreeNode], level: int) -> None:
+            if not node :
+                return
+            if len(ans) < level + 1 :
+                ans.append([node.val])
+            else:
+                ans[level].append(node.val)
+            dfs(node.left, level + 1)
+            dfs(node.right, level + 1)
+
+        dfs(root, 0)
+
+        return ans

climbing-stairs/sungjinwi.cpp

@@ -0,0 +1,31 @@
+/*
+    풀이 :
+        n이 1과 2일 떄는 따로 처리, 그 외에 n번째는 prv(n - 2번째) + cur(n -1번째)로 값을 업데이트 하며 n까지 더해나감
+
+    TC : O(N)
+        n의 크기에 반복문이 비례한다
+    
+    SC : O(1)
+        n의 크기와 상관없이 3개의 변수 사용
+*/
+
+class Solution {
+public:
+    int climbStairs(int n) {
+        if (n == 1)
+            return 1;
+        if (n == 2)
+            return 2;
+
+        int prv = 1;
+        int cur = 2;
+        int tmp;
+        for (int i = 3; i <= n; i++)
+        {
+            tmp = cur;
+            cur = cur + prv;
+            prv = tmp;
+        }
+        return cur;
+    }
+};

clone-graph/sungjinwi.py

@@ -0,0 +1,44 @@
+"""
+    풀이 :
+        재귀를 이용해서 dfs풀이
+        node를 복제하고 노드의 이웃된 노드에 대해서 재귀함수 호출을 통해 완성한다
+
+        clones 딕셔너리에 이미 복사된 node들을 저장해서 이미 복제된 node에 대해
+        함수를 호출하면 바로 return
+
+    노드의 수 : V(정점 : Vertex) 이웃의 수 : E(간선 : Edge)라고 할 때
+
+    TC : O(V + E)
+        노드와 이웃에 대해서 순회하므로
+
+    SC : O(V + E)
+        해시테이블의 크기가 노드의 수에 비례해서 커지고 
+        dfs의 호출스택은 이웃의 수만큼 쌓이므로
+"""
+
+"""
+# 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
+
+        clones = {}
+        
+        def dfs(node : Optional['Node']) -> Optional['Node']:
+            if node in clones :
+                return clones[node]
+            clone = Node(node.val)
+            clones[node] = clone
+            for nei in node.neighbors :
+                clone.neighbors.append(dfs(nei))
+            return clone
+
+        return dfs(node)

coin-change/sungjinwi.cpp

@@ -0,0 +1,36 @@
+/*
+    풀이 :
+        bottom-up dp 활용, 낮은 수부터 amount까지 차례로 해당 금액을 만들 수 있는 최소 동전 개수를 업데이트.
+        amount가 0이면 동전 개수 0이므로 dp[0] = 0으로 초기화
+        그 외의 초기값은 amount + 1로 설정
+            (1짜리 동전으로 채우면 dp[amount] 최댓값 == amount이므로 amount + 1 그대로이면 채울 수 없는 케이스)
+
+    coin 종류 : C, amount 크기 : A
+
+    TC : O(A * C)
+        amount의 크기 * coin 종류만큼 반복문
+
+    SC : O(A)
+        dp배열의 크기는 amount 크기에 비례
+*/
+
+class Solution {
+    public:
+        int coinChange(vector<int>& coins, int amount) {
+            vector<int> dp(amount + 1, amount + 1);
+    
+            dp[0] = 0;
+            for (int i = 0; i <= amount; i++)
+            {
+                for (auto coin : coins)
+                {
+                    if (i - coin >= 0)
+                        dp[i] = min(dp[i - coin] + 1, dp[i]);
+                }
+            }
+            if (dp[amount] == amount + 1)
+                return -1;
+            else
+                return dp[amount];
+        }
+    };

combination-sum/sungjinwi.cpp

@@ -0,0 +1,38 @@
+/*
+    풀이 :
+        target + 1개의 크기를 가지는 삼중벡터 dp를 만든다
+        dp[n] = dp[n - candidate]의 각 조합에 candidate를 추가하는 로직으로 쌓아나갈 것이다
+            dp[n - c]가 [comb1, comb2]일 때 dp[n]은 [comb1.push_back(c), comb2.push_back[2]]
+
+        dp[0]은 연산을 위해 빈 이중 벡터로 초기화 ( dp[n] = dp[n - n] = dp[0] --> [[].push_back(n)])
+
+    target크기 : T, candidate 갯수 : N
+
+    TC : O(T * N)
+
+    SC : O(T * N)
+*/
+
+#include <vector>
+using namespace std;
+
+class Solution {
+    public:
+        vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+            vector<vector<vector<int>>> dp(target + 1);
+            dp[0] = {{}};
+            for (int candidate : candidates)
+            {
+                for (int num = candidate; num <= target; num++)
+                {
+                    for (auto& combination : dp[num - candidate])
+                    {
+                        vector<int> new_comb = combination;
+                        new_comb.push_back(candidate);
+                        dp[num].push_back(new_comb);
+                    }
+                }
+            }
+            return dp[target];
+        }
+    };

container-with-most-water/sungjinwi.cpp

@@ -0,0 +1,32 @@
+/*
+    풀이 :
+        최대 넓이는 양 끝 기둥 길이 중 짧은 쪽을 기준으로 정해진다
+        양 끝에서 기둥을 시작하고 둘 중 짧은 쪽을 안쪽으로 이동하면서 최대 넓이를 찾는다
+
+    height의 개수 : N
+
+    TC : O(N)
+
+    SC : O(1)
+*/
+
+class Solution {
+    public:
+        int maxArea(vector<int>& height) {
+            int left = 0;
+            int right = height.size() - 1;
+            int max_area = 0;
+    
+            while (left < right)
+            {
+                int cur_area = (right - left) * min(height[left], height[right]);
+                if (cur_area > max_area)
+                    max_area = cur_area;
+                if (height[left] <= height[right])
+                    left++;
+                else
+                    right--;
+            }
+            return max_area;
+        }
+    };

container-with-most-water/sungjinwi.py

@@ -0,0 +1,26 @@
+"""
+	풀이 :
+		left, right 커서를 양 끝에 놓고 조건에 따라 반대편으로 이동시키며 물 양 비교
+		둘 중 더 높은 높이를 이동시키면 무조건 물의 양이 줄어들기 때문에 더 낮거나 같은 커서를 이동시키며 업데이트
+		둘이 만나면 비교 종료
+
+
+	len(height) : N
+	TC : O(N)
+		l, r의 이동이 전체 height 개수만큼 일어나므로
+	SC : O(1)
+"""
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l = 0
+        r = len(height) - 1
+        max_area = 0
+        while (l != r) :
+            cur_area = (r - l) * min(height[l], height[r])
+            max_area =  max(cur_area, max_area)
+            if (height[l] >= height[r]) :
+                r -= 1
+            else :
+                l += 1
+        return max_area