Week8 Seojimin

seojimin/week8/10867/Main.java

@@ -0,0 +1,41 @@
+/**
+ * 백준 10867번 - 중복 빼고 정렬하기 [정렬 알고리즘]
+ *
+ * [문제 요약]
+ * - 입력받는 숫자 정렬
+ *
+ * [해결 방법]
+ * - 배열로 숫자 받고 Arrays.sort 정렬
+ * - sb에 담으며 이전 배열에서 이미 담은 숫자와 동일하면 건너뜀
+ *
+ * [시간 복잡도]
+ * - 정렬 -> O(n log n)
+ */
+
+import java.util.Arrays;
+
+public class Main {
+
+    static void solve(int n, String[] split){
+        int[] nums = new int[n];
+        for (int i = 0; i < n; i++) nums[i] = Integer.parseInt(split[i]);
+
+        Arrays.sort(nums);
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(nums[0]).append(" ");
+        for (int i = 1; i < n; i++) {
+            if (nums[i] != nums[i - 1]) sb.append(nums[i]).append(" ");
+        }
+
+        System.out.println(sb);
+    }
+
+    public static void main(String[] args) {
+        String[] input = new String[]{"1","4","2","3","1","4","2","3","1","2"};
+
+        solve(10,input);
+    }
+
+}
+

seojimin/week8/1449/Main.java

@@ -0,0 +1,45 @@
+/**
+ * 백준 1449번 - 수리공 항승 [정렬 알고리즘]
+ *
+ * [문제 요약]
+ * - 파이프의 물새는 곳을 전부 막기 위해 필요한 테이프 수 구하기
+ *
+ * [해결 방법]
+ * - 물 새는 위치를 받은 후 오름차순 정렬
+ * - 각 구멍을 순회하며, 아직 막히지 않은 구멍이면, 새로운 테이프를 붙이고 그 길이(L)만큼 막음.
+ * - 이미 테이프가 덮인 구멍은 스킵
+ *
+ * [시간 복잡도]
+ * - 정렬 -> O(n logn)
+ * - 테이프 1000이 최대 -> O(n)
+ * - 최종 -> O(n logn)
+ */
+
+import java.util.Arrays;
+
+public class Main {
+
+    static int solve(int n, int l, int[] arr){
+
+        int[] nums = arr.clone();
+        Arrays.sort(nums);
+
+        int count = 0;
+        boolean[] tape = new boolean[1001];
+        for (int num : nums) {
+            if (!tape[num]) {
+                count++;
+                for (int i = num; i < Math.min(num + l, 1001); i++) {
+                    tape[i] = true;
+                }
+            }
+        }
+
+        return count;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{1,2,100,101};
+        System.out.println(solve(4,2,arr));
+    }
+}

seojimin/week8/18110/Main.java

@@ -0,0 +1,42 @@
+/**
+ * 백준 18110번 - solved.ac [정렬 알고리즘]
+ *
+ * [문제 요약]
+ * - 사람들이 문제에 대해 평가한 난이도가 주어진다
+ * - 절삭 평균을 적용한 평균값을 구하라
+ *
+ * [해결 방법]
+ * - 입력받은 난이도 오름차순 정렬
+ * - 그 중 15%의 반올림이 몇명인지 구함
+ * - 상,하위 15%를 제외한 나머지를 활용한 평균을 구하자
+ *
+ * [시간 복잡도]
+ * - 정렬 -> O(N logN)
+ * - 순회 -> O(N)
+ * - 최종 -> O(N logN)
+ */
+
+import java.util.Arrays;
+
+public class Main {
+
+    static int solve(int n, int[] arr){
+        int[] input = arr.clone();
+
+        Arrays.sort(input);
+
+        int cut = (int)Math.round(n * 0.15);
+
+        int sum = 0;
+        for (int i = cut; i < n-cut; i++) {
+            sum += input[i];
+        }
+
+        return (int)Math.round((double) sum / (n - cut * 2));
+    }
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{1,5,5,7,8};
+        System.out.println(solve(5, arr));
+    }
+}

seojimin/week8/2170/Main.java

@@ -0,0 +1,87 @@
+/**
+ * 백준 2170번 - 선 긋기 [정렬 알고리즘]
+ *
+ * [문제 요약]
+ * - 일직선 위에 여러 개의 선분이 주어짐 (x, y)
+ *  * - 선분들은 서로 겹칠 수 있으며, 겹치는 구간은 한 번만 계산해야 함
+ *  * - 모든 선분을 합쳤을 때의 총 길이를 구하는 문제
+ *
+ * [해결 방법]
+ * - 모든 선분 (x, y)을 입력받아 리스트에 저장
+ * -  각 선분을 시작점 x 기준으로 오름차순 정렬
+ * - 정렬된 선분들을 순회하면서 다음 규칙에 따라 병합:
+ *  * - 현재 선분의 시작점이 이전 선분의 끝보다 작거나 같으면 겹침 → 두 구간을 병합
+ *  * - 그렇지 않으면 새로운 구간으로 추가
+ * - 병합된 선분 리스트를 순회하면서 각 구간의 (끝 - 시작)을 모두 합산
+
+ * [시간 복잡도]
+ * - 정렬: O(N log N)
+ * - 병합 과정: O(N)
+ * - 종합: O(N log N)
+ */
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class Main {
+
+    static int solve(int n, int[][] lines){
+
+        // 모든 선분 (x, y)을 입력받아 리스트에 저장
+        List<int[]> inputs = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            int x = lines[i][0];
+            int y = lines[i][1];
+
+            inputs.add(new int[]{x,y});
+        }
+
+        // 각 선분을 시작점 x 기준으로 오름차순 정렬
+        inputs.sort(new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                return o1[0] - o2[0];
+            }
+        });
+
+        // 정렬된 선분들을 순회하면서 병합
+        List<int[]> result = new ArrayList<>();
+        for (int[] input : inputs) {
+            if (result.isEmpty()) {
+                result.add(input);
+                continue;
+            }
+
+            int start = input[0];
+            int end = input[1];
+
+            int[] last = result.get(result.size() - 1);
+
+            // 겹치는 경우 → 병합
+            if (last[1] >= start){
+                result.remove(result.size() - 1);
+                result.add(new int[]{last[0], Math.max(end, last[1])});
+            }
+            // 겹치지 않으면 새 구간 추가
+            else result.add(new int[]{start, end});
+        }
+
+        int sum = 0;
+        for (int[] res : result) {
+            sum += res[1] - res[0];
+        }
+
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        int[][] lines = {
+                {1,3},
+                {2,5},
+                {3,5},
+                {6,7}
+        };
+        System.out.println(solve(4, lines));
+    }
+}

seojimin/week8/2212/Main.java

@@ -0,0 +1,71 @@
+/**
+ * 백준 2212번 - 센서 [정렬 알고리즘]
+ * <p>
+ * [문제 요약]
+ * - 일직선 상에 센서들이 배치
+ * - 집중국을 설치해 센서들로부터 정보 수집
+ * - 모든 센서는 최소 하나의 집중국과 통신가능해야 함
+ * - 집중국의 개수(K)를 정해줄 때, 집중국의 수신 가능 영역 길이의 최소값 구하기
+ * <p>
+ * [해결 방법]
+ * - 1차적으로 센서들의 위치를 받고, 중복 제거 및 오름차순 정렬
+ * - 정렬된 센서들의 위치를 기반으로, 각 센서별 거리 배열을 생성
+ * - 거리 배열을 내림차순으로 정렬
+ * - 정렬된 거리 배열에서 K-1개 만큼의 거리를 제거
+ * - 나머지 거리를 종합한다.
+ * - 거리를 계산하여 활용하는 것이 포인트1
+ * - 내림차순 정렬하여, k-1개 만큼 제외하는 것이 포인트2
+ * - k-1개인 이유는 시작지점에 1개 집중국 박고 나머지 집중국을 활용해 구간을 생성하며 거리가 먼 순부터 없앤다
+ * <p>
+ * [시간 복잡도]
+ * - O(N logN)
+ */
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Arrays;
+
+public class Main {
+
+    static int solve(int n, int k, int[] input) {
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            set.add(input[i]);
+        }
+
+        if (set.size() <= k) {
+            return 0;
+        }
+
+        int[] sensor = new int[set.size()];
+        int iter = 0;
+        for (int i : set) {
+            sensor[iter++] = i;
+        }
+        Arrays.sort(sensor);
+
+        int[] distance = new int[sensor.length - 1];
+        for (int i = 1; i < sensor.length; i++) {
+            distance[i - 1] = sensor[i] - sensor[i - 1];
+        }
+
+        Arrays.sort(distance);
+        for (int i = 0; i < distance.length / 2; i++) {
+            int temp = distance[i];
+            distance[i] = distance[distance.length - 1 - i];
+            distance[distance.length - 1 - i] = temp;
+        }
+
+        int sum = 0;
+        for (int i = k - 1; i < distance.length; i++) {
+            sum += distance[i];
+        }
+
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        int[] input = new int[]{1, 6, 9, 3, 6, 7};
+        System.out.println(solve(6, 2, input));
+    }
+}