solutions

Author: haklee

climbing-stairs/haklee.py

@@ -0,0 +1,26 @@
+"""TC: O(n), SC: O(1)
+
+아이디어: 
+계단의 k번째 칸까지 도달하는 방법의 수를 f(k)라고 하자.
+f(k)는 다음의 두 경우의 수를 더한 값이다.
+  - k-2번째 칸까지 간 다음 두 칸 뜀. 즉, f(k-2)
+  - k-1번째 칸까지 간 다음 두 칸 뜀. 즉, f(k-1)
+즉, f(k) = f(k-2) + f(k-1)
+
+
+SC:
+- tabulation 과정에서 값 2개만 계속 유지한다.
+- 즉, O(1).
+
+TC:
+- 단순 덧셈 계산(O(1))을 O(n)번 반복한다.
+- 즉, O(n).
+"""
+
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        a, b = 1, 1
+        for _ in range(n - 1):
+            a, b = b, a + b
+        return b

coin-change/haklee.py

@@ -0,0 +1,51 @@
+"""TC: O(m*n), SC: O(n)
+
+coin 종류: m
+amount 크기: n
+
+아이디어: 
+값 k를 만들때 필요한 최소 동전의 수를 f(k)라고 하자.
+f(k)는 다음의 경우 중 제일 작은 값이다.
+  - 동전 c1을 마지막으로 더해서 k를 만들었다. f(k-c1) + 1개의 동전 필요.
+  - 동전 c2을 마지막으로 더해서 k를 만들었다. f(k-c2) + 1개의 동전 필요.
+  - ...
+  - 동전 cm을 마지막으로 더해서 k를 만들었다. f(k-cm) + 1개의 동전 필요.
+즉, f(k) = min(f(k-c1), f(k-c2), ..., f(k-cm)) + 1
+
+이때, n보다 작은 모든 i에 대해서 한 번 f(i)값을 계산할 일이 있었으면 이를 저장해두고 사용하는 방법으로
+접근해서 문제를 풀 수 있다.
+
+SC:
+- n보다 작은 모든 i에 대해 f(i)값을 저장해두는 배열 필요.
+- 즉, O(n).
+
+TC:
+- 각 f(i)마다 최초 계산시 m개의 아이템을 list에 넣고 min값을 찾는 계산을 한 번 한다. O(m).
+- 최초 계산이 아닐 경우 배열에 저장된 값을 가져온다. O(1).
+- 각 f(i)는 f(i+c1), f(i+c2), ..., f(i+cm)을 계산할때 호출되는데, 여기에 O(m) + O(1) + ... + O(1)
+  만큼의 시간이 소요되므로 종합하면 O(m) + (m+1)*O(1) = O(m) 만큼의 시간이 소요된다.
+- 이러한 f(i)값이 총 n개 있다. 즉, O(m*n).
+"""
+
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        arr = [None for _ in range(amount + 1)]  # None값은 아직 계산되지 않았다는 뜻.
+        arr[0] = 0  # 초기화
+
+        def dp(target):
+            if arr[target] is None:  # 만약 아직 f(target)이 계산되지 않았다면
+                # 모든 동전들 c에 대해 f(target - c)는 다음의 경우들만 유효하다.
+                # - target이 동전 c의 크기 이상은 되어야 한다.
+                # - 앞서 계산해본 결과 총 금액 target - c를 구할 수 없는 경우는 무시.
+                #    - 구할 수 없는 것으로 판명된 경우 f(x)의 값이 -1이다.
+                candidates = [
+                    v for c in coins if target - c >= 0 and (v := dp(target - c)) >= 0
+                ]
+                # candidates에 유효한 f(target - c)값이 하나도 없으면 f(target)은 -1이다.
+                # 그게 아니라면 candidates에 들어있는 값 중 제일 적은 수의 동전을 필요로 하는
+                # 경우에 1을 더한 값을 f(target)에 넣어둠.
+                arr[target] = -1 if len(candidates) == 0 else min(candidates) + 1
+            return arr[target]
+
+        return dp(amount)

combination-sum/haklee.py

@@ -0,0 +1,114 @@
+"""TC: O(m^n), SC: O(m^n)
+
+candidates에 있는 값의 개수: m
+target의 크기: n
+
+아이디어: 
+candidates(이하 cands)에 있는 숫자들을 더해서 k를 만드는 방법을 f(k)라고 하자.
+f(k)는 다음의 경우들을 종합한 것이다.
+  - cands에 있는 c1을 마지막으로 더해서 k를 만들었다. 즉, f(k-c1)에 있는 모든 방법의 끝에 c1을 더함.
+  - cands에 있는 c2를 마지막으로 더해서 k를 만들었다. 즉, f(k-c2)에 있는 모든 방법의 끝에 c2을 더함.
+  ...
+  - cands에 있는 cm을 마지막으로 더해서 k를 만들었다. 즉, f(k-cm)에 있는 모든 방법의 끝에 cm을 더함.
+
+이렇게 하면 문제는, 하나의 값을 만드는 데에 중복된 경우가 나올 수 있다는 것이다.
+e.g.) candidates = [2, 3], target = 5
+f(2) = [[2]]
+f(3) = [[3]]
+위의 값을 활용해서 f(5)를 구하면
+f(5) = [f(2)의 방법들의 끝에 3을 붙임] + [f(3)의 방법들의 끝에 2를 붙임]
+     = [[2, 3]] + [[3, 2]]
+     = [[2, 3], [3, 2]]
+
+그래서 마지막에 같은 아이템으로 이루어진 리스트를 찾아서 중복을 제거해준다.
+
+이번 문제에서는 [2, 2, 3], [2, 3, 2], [3, 2, 2] 같이 들어가는 아이템의 순서만 다른 경우를 같은 것으로
+보았기 때문에 마지막에 중복을 제거했지만, 만약 이들을 서로 다른 방법으로 보는 문제가 주어진다면 위의
+결과를 그대로 리턴하면 된다.
+
+
+SC:
+- 문제 특성상 f(i)에 들어갈 수 있는 방법의 수는
+    - i를 만드는 방법의 길이는 O(i).
+        - cands에 1이 있고 이 1로 가득 채운 방법 [1, 1, ..., 1]을 생각하면 편하다.
+        - cands의 최소값이 어떤 상수 x라고 해도 [x, x, ..., x]에는 i/x가 들어가는데, O(i/x)는 O(i).
+    - 각 방법에 들어있는 아이템은 m가지 경우의 수가 가능. [(c1, c2, ..., cm 중 하나), ..., (c1, c2, ..., cm 중 하나)]
+    - 즉, f(i)에는 O(m^i)가지 경우가 들어갈 수 있다.
+- f(1), f(2), ..., f(n)을 다 더하면 O(m^1) + O(m^2) + ... + O(m^n) = O(m^n)이 된다.
+- 즉, O(m^n).
+
+TC:
+- 위의 SC와 같은 방식으로 접근이 가능하다. O(m^n).
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]  # 초기화.
+        dp[0] = [[]]  # 0을 만드는 방법은 아무 숫자도 넣지 않는 것 한 가지 방법이 있다.
+        for cur in range(1, target + 1):  # f(i)를 1부터 계산해나가면서 채우기 시작.
+            for cand in candidates:
+                prev = cur - cand
+                if prev >= 0:
+                    dp[cur] += [combi + [cand] for combi in dp[prev]]
+
+        # 마지막에 중복된 경우를 제거해준다.
+        return list(set([tuple(sorted(i)) for i in dp[target]]))
+
+
+"""
+아이디어:
+중간중간 계산하면서 중복된 값을 제거하면서 f(i)값을 관리하는 식으로 커팅하는 것이 가능하다.
+각 방법은 [c1, ...c1, c2, ..., c2, ... , cm, ..., m] 꼴이 되는데,
+          [         ^            ^ ... ^           ] 
+각 f(i)마다 위의 `^` 표시를 해둔 곳을 찾는 방법의 수만큼 공간이 필요하다.
+이 숫자는 대략 (i choose m-1)이라고 생각할 수 있다.
+
+그러므로 SC와 TC 모두 O(n choose m) = O((n/m)^m)...?
+(ref: https://en.wikipedia.org/wiki/Binomial_coefficient#Bounds_and_asymptotic_formulas)
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]
+        dp[0] = [[]]
+        for cur in range(1, target + 1):
+            for cand in candidates:
+                prev = cur - cand
+                if prev >= 0:
+                    dp[cur] += [combi + [cand] for combi in dp[prev]]
+            dp[cur] = list(set([tuple(sorted(i)) for i in dp[cur]]))
+        return list(set([tuple(sorted(i)) for i in dp[target]]))
+
+
+"""
+아이디어:
+만들고 나서 중복된 경우를 제거하지 말고, 처음부터 중복된 결과를 만들지 않는 것도 방법이다.
+각 방법마다 해당 방법에서 사용한 최대 candidate 인덱스를 달아두고, 이후 해를 구할 때는 해당
+인덱스 이상의 candidate만 추가할 수 있도록 단서를 달아두는 방식으로 구현 가능하다.
+e.g.) candidate = [2, 5, 3]
+f(10)에 들어있을 수 있는 방법은
+- ([2, 2, 2, 2, 2], 0) : 마지막 아이템 이후에 2, 5, 3 전부 등장 가능.
+- ([5, 5], 1) : 마지막 아이템 이후에 5, 3만 등장 가능.
+- ([2, 5, 3], 2) : 마지막 아이템 이후에 3만 등장 가능.
+- ([2, 2, 3, 3], 2) : 마지막 아이템 이후에 3만 등장 가능.
+
+SC와 TC는 바로 위에서 O(n choose m)을 계산한 것과 같을 것으로 보인다.
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        dp = [[] for _ in range(target + 1)]
+        dp[0] = [([], 0)]  # (방법, 사용 가능한 candidate index 최소값) 쌍.
+        for cur in range(1, target + 1):
+            for i in range(len(candidates)):
+                prev = cur - candidates[i]
+                if prev >= 0:
+                    dp[cur] += [
+                        (combi[0] + [candidates[i]], i)
+                        for combi in dp[prev]
+                        if i >= combi[1]
+                    ]
+        return [i[0] for i in dp[target]]  # 방법만 추출해서 리턴한다.

product-of-array-except-self/haklee.py

@@ -0,0 +1,49 @@
+"""TC: O(n), SC: O(n)
+
+아이디어: 
+다음의 세 상황 중 하나가 될 것이다.
+- 0이 둘 이상 포함. 모든 결과값이 0이 된다.
+- 0이 하나 포함.
+    - 0에 해당하는 인덱스에는 nums에 있는 숫자들 중 0 말고 나머지 숫자들을 전부 곱한 값.
+    - 그 외 모두 0.
+- 0이 하나도 없다.
+    - nums에 있는 모든 숫자들을 곱한 값을 p라고 할때, 각 인덱스 i마다 p를 nums[i]로 나눈 값.
+
+그러므로, 먼저 nums에 있는 숫자들을 돌면서
+- 0이 아닌 숫자를 전부 곱한 값 p를 만든다.
+- 0이 들어있는 인덱스를 찾는다.
+
+그 다음
+- 0이 들어있는 인덱스의 길이를 보고 위의 세 상황 중 하나에 대응해서 결과값을 리턴한다.
+
+SC:
+- 0이 아닌 숫자들을 곱한 값 p를 관리할때 O(1)
+- 0이 등장하는 인덱스 zero_ind를 관리할때 O(n)
+- 결과로 리턴할 값 O(n)
+- 종합하면 O(n).
+
+TC:
+- nums값을 한 번 순회하면서 p, zero_ind값을 업데이트 할때 O(n)
+- 결과로 리턴할 값 만들때 O(n)
+- 종합하면 O(n).
+"""
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        zero_ind = []
+        p = 1
+        for i, e in enumerate(nums):
+            if e == 0:
+                zero_ind.append(i)
+            else:
+                p *= e
+
+        sol = [0] * len(nums)
+        if len(zero_ind) > 1:
+            return sol
+        elif len(zero_ind) == 1:
+            sol[zero_ind[0]] = p
+            return sol
+        else:
+            return [p // i for i in nums]

two-sum/haklee.py

@@ -0,0 +1,53 @@
+"""TC: O(n), SC: O(n)
+
+아이디어: 
+만약 nums에 있는 어떤 숫자 i에 대해 target - i도 nums 안에 있다면, 이 두 숫자의 인덱스를 리턴하면 된다.
+그런데 이렇게 하면 다음과 같은 예외 상황이 발생할 수 있다.
+
+case 1) nums = [3, 3], target = 6
+- nums에 3이 두 번 나오면 i도 3이고 target - i도 3인데, 그럼 같은 숫자에 대해서 어떻게 서로 다른 인덱스를
+  가져오는가?
+case 2) nums = [2, 3, 4], target = 6
+- nums에 3이 하나밖에 없는데, i = 3일때 i도 nums 안에 있고, target - i = 3이라 이 값도 nums 안에 있다.
+  서로 다른 두 아이템을 더해서 6이 되어야 하므로 [1, 1]같은 답을 리턴하면 오답이다.
+
+위의 문제를 해결하기 위해 다음과 같은 방법을 사용했다.
+- nums에 있는 unique한 숫자에 대해 각 숫자의 마지막 인덱스를 dict로 저장한다.
+- 만약 nums에 속하는 어떤 수 i에 대해 i와 target - i의 값이 같을 경우, nums 안에 있는 i 중에 제일 앞에 있는
+  i의 인덱스를 찾아서 앞서 만든 dict에 있는 인덱스와 비교해서 다른지 확인한다.
+
+Q) 그런데 만약 i, target - i 값이 서로 다를때 둘 중 하나라도 nums 안에 두 번 이상 등장하면 어떡하지...?
+A) 그럴 일은 없다. 솔루션은 유일하기 때문에, i나 target - i가 두 번 이상 나오면 솔루션이 둘 이상이 됨.
+
+
+SC:
+- ind_dict를 만들 때랑 nums_set 만들때 각각 O(n).
+- 즉, O(n)
+
+TC:
+- ind_dict를 만들때 O(n).
+- nums_set에 있는 값의 개수만큼 순회, O(n)
+    - 내부에서 일어나는 일은 O(1)
+- 종합하면 O(n).
+"""
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        # 먼저 nums의 각 아이템마다 인덱스를 찾는다.
+        # 여기서 주의할 것은, nums에 같은 숫자가 두 번 이상 나오면 마지막 아이템의 인덱스가 들어감.
+        ind_dict = {k: i for i, k in enumerate(nums)}  # SC: O(n), TC: O(n)
+
+        # nums에 있는 unique한 값 i마다,
+        for i in (nums_set := set(nums)):  # SC: O(n), TC: O(n)
+            # 만약 target - i도 nums 안에 있다면,
+            if target - i in nums_set:
+                # 그리고 i와 target - i가 서로 다른 숫자라면,
+                if i != target - i:
+                    # 쉬운 케이스. 그냥 두 숫자의 인덱스를 찾아서 결과로 리턴한다.
+                    return [ind_dict[i], ind_dict[target - i]]
+
+                # 여기에 도달했다면 i와 target - i값이 같음.
+                if (x := nums.index(i)) != ind_dict[target - i]:
+                    # 첫, 마지막 등장 인덱스가 다를 경우, 이 두 숫자를 리턴.
+                    return [x, ind_dict[target - i]]