Merge branch 'DaleStudy:main' into main

Author: sukyoungshin

3sum/haung921209.md

@@ -0,0 +1,67 @@
+```cpp
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        set<vector<int>> res;
+        for(int i=0;i<nums.size();i++){
+            int l = i+1, r = nums.size()-1;
+
+            while(l<r){
+                int sum = nums[i]+nums[l]+nums[r];
+
+                if(sum<0){
+                    l++;
+                }else if(sum>0){
+                    r--;
+                }else{
+                    res.insert({nums[i], nums[l], nums[r]});
+                    l++;
+                    r--;
+                }
+            }
+        }
+
+        return vector<vector<int>>(res.begin(), res.end());
+    }
+};
+```
+
+- set -> vector 사용 이유는 중복 제거를 위함
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        set<vector<int>> res;
+        for(int i=0;i<nums.size();i++){
+            if(i != 0 && nums[i] == nums[i-1]) continue;
+
+            int l = i+1, r = nums.size()-1;
+
+            while(l<r){
+                int sum = nums[i]+nums[l]+nums[r];
+
+                if(sum<0){
+                    l++;
+                }else if(sum>0){
+                    r--;
+                }else{
+                    res.insert({nums[i], nums[l], nums[r]});
+                    l++;
+                    r--;
+                }
+            }
+        }
+
+        return vector<vector<int>>(res.begin(), res.end());
+
+    }
+};
+```
+
+- `if(i != 0 && nums[i] == nums[i-1]) continue;` 를 통한 탐색 범위 줄이기 최적화 정도의 차이로 상 / 하위 갈리는 정도
+- 단순 2 pointer로 처리해도 무방
+
+

climbing-stairs/haung921209.md

@@ -0,0 +1,18 @@
+```cpp
+class Solution {
+public:
+    int climbStairs(int n) {
+        vector<int> dp = {0, 1, 2};
+        dp.resize(n+1);
+        for(int i=3;i<=n;i++){
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+        return dp[n];
+    }
+};
+```
+- O(n)
+- dp
+
+
+

combination-sum/Tessa1217.java

@@ -0,0 +1,36 @@
+import java.util.List;
+import java.util.ArrayList;
+/**
+ 중복 되지 않은 요소들이 들어있는 candidates 배열이 주어지고 target 값이 주어진다.
+ 합이 target과 같은 중복되지 않은 조합을 모두 반환하시오.
+ */
+class Solution {
+
+    List<List<Integer>> answer = new ArrayList<>();
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        combination(0, candidates, target, 0, new ArrayList<>());
+        return answer;
+    }
+
+    // 시간복잡도 O(2^target)
+    public void combination(int idx, int[] candidates, int target, int currentSum, List<Integer> comb) {
+        // 누적 합이 넘으면
+        if (currentSum > target) {
+            return;
+        }
+
+        // 누적 합이 타겟 값과 같으면
+        if (currentSum == target) {
+            answer.add(new ArrayList<>(comb));
+            return;
+        }
+
+        for (int i = idx; i < candidates.length; i++) {
+            comb.add(candidates[i]);
+            combination(i, candidates, target, currentSum + candidates[i], comb);
+            comb.remove(comb.size() - 1);
+        }
+    }
+}
+

combination-sum/printjin-gmailcom.py

@@ -0,0 +1,15 @@
+class Solution:
+    def combinationSum(self, candidates, target):
+        output, nums = [], []
+        def dfs(start, total):
+            if total > target:
+                return
+            if total == target:
+                return output.append(nums[:])
+            for i in range(start, len(candidates)):
+                num = candidates[i]
+                nums.append(num)
+                dfs(i, total + num)
+                nums.pop()
+        dfs(0, 0)
+        return output

combination-sum/uraflower.js

@@ -0,0 +1,44 @@
+/**
+ * 주어진 배열의 원소 조합(중복 허용)의 합이 target인 모든 경우를 반환하는 함수
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+const combinationSum = function(candidates, target) {
+    const sortedCandidates = candidates.filter((x) => x <= target).sort((a, b) => Number(a) - Number(b));
+    const answer = [];
+    
+    if (sortedCandidates.length === 0) {
+        return answer;
+    }
+
+    function search(currentIdx, combination, total) {
+        if (total === target) {
+            answer.push([...combination]); // 배열 자체를 넣으면 참조 때문에 값이 변경되므로, 복사해서 넣어야 함
+            return;
+        }
+
+        if (total > target) {
+            return; // backtracking
+        }
+
+        combination.push(sortedCandidates[currentIdx]);
+        search(currentIdx, combination, total + sortedCandidates[currentIdx]);
+        combination.pop();
+
+        if (total + sortedCandidates[currentIdx] > target) {
+            return; // backtracking
+        }
+
+        if (currentIdx + 1 < sortedCandidates.length) {
+            search(currentIdx + 1, combination, total);
+        }
+    }
+
+    search(0, [], 0);
+    return answer;
+};
+
+// t: target
+// 시간복잡도: O(2^t)
+// 공간복잡도: O(t)

decode-ways/Tessa1217.java

@@ -0,0 +1,43 @@
+/**
+ 주어진 문자열을 복호화 할 수 있는 경우의 수를 반환하시오.
+ 문자열은 A-Z까지 숫자 1-26으로 치환
+ 예시: "AAJF" => (1, 1, 10, 6), (11, 10, 6)...
+ */
+class Solution {
+
+    // 시간복잡도: O(n), 공간복잡도: O(n)
+    public int numDecodings(String s) {
+
+        int[] dp = new int[s.length() + 1];
+
+        // contain leading zero(s)
+        if (s.charAt(0) == '0') {
+            return 0;
+        }
+
+        dp[0] = 1;
+        dp[1] = 1;
+
+        for (int i = 2; i <= s.length(); i++) {
+
+            // 1자리수 검사
+            int one = Integer.parseInt(Character.toString(s.charAt(i - 1)));
+
+            if (one != 0) {
+                dp[i] += dp[i - 1];
+            }
+
+            // 2자리수 검사
+            int two = Integer.parseInt(Character.toString(s.charAt(i - 2))) * 10 + one;
+
+            if (two >= 10 && two <= 26) {
+                dp[i] += dp[i - 2];
+            }
+
+        }
+
+        return dp[s.length()];
+    }
+
+}
+

decode-ways/printjin-gmailcom.py

@@ -0,0 +1,13 @@
+class Solution:
+    def numDecodings(self, s):
+        if not s:
+            return 0
+        dp = [0] * (len(s) + 1)
+        dp[0] = 1 
+        dp[1] = 1 if s[0] != '0' else 0 
+        for i in range(2, len(s) + 1):
+            if '1' <= s[i - 1] <= '9':
+                dp[i] += dp[i - 1]
+            if '10' <= s[i - 2:i] <= '26':
+                dp[i] += dp[i - 2]
+        return dp[len(s)]  

decode-ways/uraflower.js

@@ -0,0 +1,36 @@
+/**
+ * 주어진 문자열을 복호화하는 경우의 수를 반환하는 함수
+ * @param {string} s
+ * @return {number}
+ */
+const numDecodings = function(s) {
+    const dp = {};
+
+    function decode(idx) {
+        if (s[idx] === '0') {
+            return 0;
+        }
+
+        if (idx === s.length) {
+            return 1;
+        }
+
+        if (dp[idx]) {
+            return dp[idx];
+        }
+
+        let result = 0;
+        result += decode(idx + 1); // 현재 문자만 쓰는 경우: 다음 문자부터 탐색
+        if (s[idx + 1] && Number(s[idx] + s[idx+1]) <= 26) {
+            result += decode(idx + 2); // 현재 문자와 다음 문자 붙여서 쓰는 경우: 다다음 문자부터 탐색
+        }
+
+        dp[idx] = result;
+        return result;
+    }
+
+    return decode(0);
+};
+
+// 시간복잡도: O(n) (메모이제이션 안하면 매 인덱스마다 최대 2개의 하위 호출이 발생하여 O(2^n))
+// 공간복잡도: O(n)

maximum-subarray/Tessa1217.java

@@ -0,0 +1,21 @@
+/**
+ 정수 배열이 주어질 때 부분 수열의 가장 큰 합을 구하시오.
+ */
+class Solution {
+
+    // 시간복잡도: O(n), 공간복잡도: O(1)
+    public int maxSubArray(int[] nums) {
+
+        int sum = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            // 수 이어서 더할지 아니면 현재 값으로 초기화할지 여부 판단
+            nums[i] = Math.max(nums[i], nums[i] + nums[i - 1]);
+            sum = Math.max(nums[i], sum);
+        }
+
+        return sum;
+    }
+
+}
+

maximum-subarray/printjin-gmailcom.py

@@ -0,0 +1,7 @@
+class Solution:
+    def maxSubArray(self, nums):
+        max_sum = current_sum = nums[0]
+        for num in nums[1:]:
+            current_sum = max(num, current_sum + num)
+            max_sum = max(max_sum, current_sum)
+        return max_sum