[최원준] Day02

leetcode2/1easy/최원준/Q3402.java

@@ -0,0 +1,29 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+전 행의 값보다 1 큰 값으로 채워 넣습니다.
+
+2. 시간복잡도 :
+O( n * m )
+
+3. 자료구조/알고리즘 :
+- / 브루트 포스
+ */
+
+public class Q3402 {
+    class Solution {
+        public int minimumOperations(int[][] grid) {
+            int n = grid.length, m = grid[0].length;
+            int ans = 0;
+            for (int row = 1; row<n; row++) {
+                for (int col = 0; col<m; col++) {
+                    int prev = grid[row-1][col];
+                    ans+= Math.max(0, (prev+1) - grid[row][col]);
+                    grid[row][col] = Math.max(grid[row][col], prev+1);
+                }
+            }
+            return ans;
+        }
+    }
+}

leetcode2/2medium/최원준/Q2770.java

@@ -0,0 +1,37 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+dp를 사용해서 최대값을 구합니다.
+start에서 end로 이동할 때, nums[end] - nums[start]의 절대값이 target 이하인지 확인.
+가능하다면 dp[end]를 갱신.
+
+2. 시간복잡도 :
+O( n * n)
+
+3. 자료구조/알고리즘 :
+배열 / DP
+ */
+
+import java.util.Arrays;
+
+public class Q2770 {
+    class Solution {
+        public int maximumJumps(int[] nums, int target) {
+            int n = nums.length;
+            int[] dp = new int[n];
+            Arrays.fill(dp, -1);
+            dp[0] = 0;
+
+            for (int start = 0; start < n; start++) {
+                if (dp[start] == -1) continue;
+                for (int end = start + 1; end < n; end++) {
+                    int diff = nums[end] - nums[start];
+                    if (Math.abs(diff) <= target) dp[end] = Math.max(dp[end], dp[start]+1);
+                }
+            }
+
+            return dp[n-1];
+        }
+    }
+}

leetcode2/3hard/최원준/Q1655.java

@@ -0,0 +1,74 @@
+package Leetcode.최원준;
+
+/*
+1. 아이디어 :
+quantity는 10개 이하, nums의 종류는 50개 이하.
+이떄 nums의 값은 중요하지 않고, 각 값의 개수만 중요.
+각 값의 개수를 counts에 저장.
+quantity를 내림차순으로 정렬하여, 빠르게 실패 하는 경우를 줄임.
+
+백트래킹을 통해서, 각 quantity마다 counts에서 값을 빼가며 조합을 찾습니다.
+
+2. 시간복잡도 :
+O( n + mlogm + 50^m )
+
+3. 자료구조/알고리즘 :
+리스트, 맵 / 백트래킹
+ */
+
+import java.util.*;
+
+public class Q1655 {
+    class Solution {
+        List<Integer> counts = new ArrayList<>();
+        Map<Integer, Integer> counter = new HashMap<>();
+        int[] nums, quantity;
+        int n, m;
+        boolean ans = false;
+
+        public void backtrack(int idx) {
+            if (ans) return;
+            if (idx == m) {
+                ans = true;
+                return;
+            }
+
+            int q = quantity[idx];
+            for (int i=0; i<counts.size(); i++) {
+                int val = counts.get(i);
+                if (val < q) continue;
+
+                counts.set(i, val-q);
+                backtrack(idx+1);
+                counts.set(i, val);
+            }
+        }
+
+        public boolean canDistribute(int[] nums, int[] quantity) {
+            this.nums = nums;
+            this.quantity = quantity;
+            n = nums.length;
+            m = quantity.length;
+
+            for (int num : nums) counter.put(num, counter.getOrDefault(num, 0)+1);
+            counts.addAll(counter.values());
+            Arrays.sort(quantity);
+            reverse(quantity);
+
+            backtrack(0);
+
+            return ans;
+        }
+
+        public void reverse(int[] arr) {
+            int l = 0, r = arr.length-1;
+            while (l<r) {
+                int temp = arr[l];
+                arr[l] = arr[r];
+                arr[r] = temp;
+                l++;
+                r--;
+            }
+        }
+    }
+}