10,11주차_심정민

Author: jeonmin

10주차/jeongmin/86.java

@@ -0,0 +1,40 @@
+import java.util.*;
+
+class Solution {
+    public int leastInterval(char[] tasks, int n) {
+        // 각 작업의 빈도 수 계산
+        int[] freqs = new int[26];
+        for (char c : tasks) freqs[c - 'A']++;
+
+        // 최대 빈도수를 우선 순위로 두는 우선순위 큐
+        Queue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int f : freqs)
+            if (f > 0) pq.add(f);
+
+        int result = 0;
+
+        // 작업을 처리
+        while (!pq.isEmpty()) {
+            int intervals = 0;
+            List<Integer> list = new ArrayList<>();
+
+            // 최대 n + 1개의 작업을 처리
+            for (int i = 0; i <= n; i++) {
+                if (!pq.isEmpty()) {
+                    int frequency = pq.poll();
+                    intervals++;
+                    result++;
+                    if (frequency > 1) list.add(frequency - 1);
+                }
+            }
+
+            // 남아 있는 작업들을 다시 큐에 넣음
+            pq.addAll(list);
+
+            // 남은 작업이 있으면 대기 시간이 발생
+            if (!pq.isEmpty()) result += n + 1 - intervals;
+        }
+
+        return result;
+    }
+}

10주차/jeongmin/87.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        //방문 가능한 입력값인지 필터링
+        if(Arrays.stream(gas).sum()<Arrays.stream(cost).sum())
+            return -1;
+
+        int start=0,fuel=0;
+
+        //전체 주유소를 순회하면서 성립되지 않는 위치를 찾는다.
+        //남은 기름으로 출발점이 안 되는 주요소가 있다면 이미 지나친 지점도 전부 출발점이 될수 없으므로
+        //출발점을 다음지점으로 밀어낸다.
+        for(int i=0;i<gas.length;i++){
+            if(fuel+gas[i]-cost[i]<0){
+                start=i+1;
+                fuel=0;
+            }else{
+                //남은 기름을 계속 누적한다.
+                fuel+=gas[i]-cost[i];
+            }
+        }
+        return start;
+
+
+    }
+}

10주차/jeongmin/89.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Solution {
+    public int majorityElement(int[] nums) {
+        Map<Integer, Integer> countsMap = new HashMap<>();
+
+        // 숫자의 빈도를 계산
+        for (int num : nums) {
+            countsMap.put(num, countsMap.getOrDefault(num, 0) + 1);
+        }
+
+        // 빈도를 기준으로 내림차순 정렬
+        Map<Integer, Integer> reverseSortedMap = new LinkedHashMap<>();
+        countsMap.entrySet()
+                .stream()
+                .sorted(Map.Entry.<Integer, Integer>comparingByValue(Comparator.reverseOrder()))
+                .forEachOrdered(x -> reverseSortedMap.put(x.getKey(), x.getValue()));
+
+        // 첫 번째 엔트리가 과반수를 차지하는지 확인
+        Map.Entry<Integer, Integer> entry = reverseSortedMap.entrySet().iterator().next();
+
+        if (entry.getValue() > nums.length / 2) return entry.getKey();
+
+        return -1;
+    }
+}

11주차/jeongmin/93.java

@@ -0,0 +1 @@
+

11주차/jeongmin/94.java

@@ -0,0 +1,16 @@
+
+class Solution {
+    public int rob(int[] nums) {
+
+        if(n<0)return 0;
+
+        return Math.max(
+                rob(nums,n-1),
+                rob(nums,n-2)+nums[n]
+        );
+    }
+
+    public int rob(int[]nums){
+        return rob(nums,nums.length-1);
+    }
+}

11주차/jeongmin/95.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int solution(int[] money) {
+        if (money.length == 1) return money[0];
+
+        int[][] dp = new int[2][money.length];
+
+        dp[0][0] = 0;  // Including the first house
+        dp[1][0] = 0;         // Excluding the first house
+        dp[0][1] = 0;  // Cannot take both first and second house
+        dp[1][1] = money[1];  // Starting from the second house
+
+        for (int i = 2; i < money.length; i++) {
+            dp[0][i] = Math.max(dp[0][i - 1], dp[0][i - 2] + money[i]);
+            dp[1][i] = Math.max(dp[1][i - 1], dp[1][i - 2] + money[i]);
+        }
+
+        // Return the maximum of either robbing from the first house or starting from the second house
+        return Math.max(money[0]+dp[0][money.length - 2], dp[1][money.length - 1]);
+    }
+}