Merge branch 'DaleStudy:main' into main

Author: taurus09318976

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/RiaOh.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+  const arr = [1, 2];
+  for (let i = 2; i <= n - 1; i++) {
+    arr[i] = arr[i - 2] + arr[i - 1];
+  }
+  return arr[n - 1];
+};

climbing-stairs/choidabom.js

@@ -0,0 +1,16 @@
+// https://leetcode.com/problems/climbing-stairs/
+
+// TC: O(N)
+// SC: O(N)
+
+var climbStairs = function (n) {
+  const stairs = [1, 2];
+
+  for (let i = 2; i < n; i++) {
+    stairs[i] = stairs[i - 1] + stairs[i - 2];
+  }
+
+  return stairs[n - 1];
+};
+
+console.log(climbStairs(5));

climbing-stairs/froggy1014.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    if (n === 1) return 1;
+    if (n === 2) return 2;
+    
+    let dp = new Array(n + 1).fill(0);
+    dp[1] = 1;
+    dp[2] = 2;
+    for (let i = 3; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+};
+
+
+console.log(climbStairs(4));

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
+
+
+

coin-change/HoonDongKang.ts

@@ -0,0 +1,72 @@
+/**
+ * [Problem]: [322] Coin Change
+ *
+ * (https://leetcode.com/problems/coin-change/description/)
+ */
+function coinChange(coins: number[], amount: number): number {
+    // 시간복잡도: O(c^a)
+    // 공간복잡도: O(a)
+    // Time Exceed
+    function dfsFunc(coins: number[], amount: number): number {
+        if (!amount) return 0;
+        let result = dfs(amount);
+
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const result = dfs(remain - coin);
+                min_count = Math.min(min_count, result + 1);
+            }
+
+            return min_count;
+        }
+    }
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function dpFunc(coins: number[], amount: number): number {
+        const dp = new Array(amount + 1).fill(amount + 1);
+        dp[0] = 0;
+
+        for (let coin of coins) {
+            for (let i = coin; i <= amount; i++) {
+                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+            }
+        }
+
+        return dp[amount] <= amount ? dp[amount] : -1;
+    }
+
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function memoizationFunc(coins: number[], amount: number): number {
+        const memo: Record<number, number> = {};
+
+        const result = dfs(amount);
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+            if (remain in memo) return memo[remain];
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const res = dfs(remain - coin);
+                min_count = Math.min(min_count, res + 1);
+            }
+
+            memo[remain] = min_count;
+
+            return min_count;
+        }
+    }
+
+    return memoizationFunc(coins, amount);
+}

coin-change/JEONGBEOMKO.java

@@ -0,0 +1,19 @@
+class Solution {
+    /*
+    time complexity: O(amount × n)
+    space complexity: O(amount)
+    */
+    public int coinChange(int[] coins, int amount) {
+        int[] memo = new int[amount + 1];
+        Arrays.fill(memo, amount + 1); // 초기값: 만들 수 없는 큰 수
+        memo[0] = 0; // 0원을 만들기 위한 동전 수는 0개
+
+        for (int coin : coins) {
+            for (int i = coin; i <= amount; i++) {
+                memo[i] = Math.min(memo[i], memo[i - coin] + 1);
+            }
+        }
+
+        return memo[amount] > amount ? -1 : memo[amount];
+    }
+}

coin-change/Jeehay28.ts

@@ -0,0 +1,72 @@
+// Approach 2: Dynamic Programming
+// // Time Complexity: O(amout * n), where n is the number of coins
+// // Space Complexity: O(amount)
+
+function coinChange(coins: number[], amount: number): number {
+
+    // input: coins = [2, 3, 5], amount = 7
+
+    // initial state dp
+    // 0: 0 
+    // 1: amount + 1 = 8
+    // 2: 8
+    // 3: 8
+    // 4: 8
+    // 5: 8
+    // 6: 8
+    // 7: 8
+
+    // using coin 2
+    // 0: 0 
+    // 1: 8
+    // 2: 8 -> 8 vs dp[2-2] + 1 = 1 -> 1 
+    // 3: 8 -> 8 vs dp[3-2] + 1 = 9 -> 8 
+    // 4: 8 -> 8 vs dp[4-2] + 1 = 2 -> 2
+    // 5: 8 -> 8 vs dp[5-2] + 1 = 9 -> 8
+    // 6: 8 -> 8 vs dp[6-2] + 1 = 3 -> 3
+    // 7: 8 -> 8 vs dp[7-2] + 1 = 9 -> 8
+
+    const dp = Array.from({ length: amount + 1 }, () => amount + 1);
+    dp[0] = 0
+
+    for (const coin of coins) {
+        for (let currentTotal = coin; currentTotal <= amount; currentTotal++) {
+            dp[currentTotal] = Math.min(dp[currentTotal - coin] + 1, dp[currentTotal])
+        }
+    }
+  
+    return dp[amount] > amount ? -1 : dp[amount]
+};
+
+
+// // Approach 1: BFS Traversal
+// // Time Complexity: O(amout * n), where n is the number of coins
+// // Space Complexity: O(amount)
+
+// function coinChange(coins: number[], amount: number): number {
+//   // queue: [[number of coints, current total]]
+//   let queue = [[0, 0]];
+//   let visited = new Set();
+
+//   while (queue.length > 0) {
+//     const [cnt, total] = queue.shift()!;
+
+//     if (total === amount) {
+//       return cnt;
+//     }
+
+//     if (visited.has(total)) {
+//       continue;
+//     }
+//     visited.add(total);
+
+//     for (const coin of coins) {
+//       if (total + coin <= amount) {
+//         queue.push([cnt + 1, total + coin]);
+//       }
+//     }
+//   }
+
+//   return -1;
+// }
+

coin-change/PDKhan.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    public:
+        int coinChange(vector<int>& coins, int amount) {
+            vector<int> dp(amount+1, amount+1);
+    
+            dp[0] = 0;
+            
+            for(int i = 1; i <= amount; i++){
+                for(int j = 0; j < coins.size(); j++){
+                    if(i >= coins[j])
+                        dp[i] = min(dp[i], 1 + dp[i - coins[j]]);
+                }
+            }
+    
+            if(dp[amount] > amount)
+                return -1;
+    
+            return dp[amount];
+        }
+    };

coin-change/Tessa1217.java

@@ -0,0 +1,26 @@
+/**
+ * 정수 배열 coins가 주어졌을 때 amount를 만들 기 위해 최소한의 동전 개수를 반환하세요.
+ 만약 동적으로 amount 조합을 만들어낼 수 없다면 -1을 리턴하세요.
+ */
+import java.util.Arrays;
+
+class Solution {
+
+    // 시간복잡도: O(n * amount), 공간복잡도: O(amount)
+    public int coinChange(int[] coins, int amount) {
+        int[] coinCnt = new int[amount + 1];
+        // coins[i]의 최댓값이 2^31 - 1 이므로 최댓값 설정
+        Arrays.fill(coinCnt, Integer.MAX_VALUE - 1);
+        coinCnt[0] = 0;
+        for (int i = 0; i < coins.length; i++) {
+            for (int j = coins[i]; j < amount + 1; j++) {
+                coinCnt[j] = Math.min(coinCnt[j], coinCnt[j - coins[i]] + 1);
+            }
+        }
+        if (coinCnt[amount] == Integer.MAX_VALUE - 1) {
+            return -1;
+        }
+        return coinCnt[amount];
+    }
+}
+