Merge pull request #18 from GreatAlgorithm-Study/xubin

[2주차] 배수빈

Author: baexxbin

BOJ/1000-10000번/SB_1647.java

@@ -0,0 +1,82 @@
+/*
+* 도시 분할 계획
+* */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class SB_1647 {
+    static int N, M;
+    static List<Node> adj = new ArrayList<>();
+    static int[] parent;
+
+    private static int find(int x) {
+        if (x != parent[x])
+            parent[x] = find(parent[x]);
+        return parent[x];
+    }
+
+    private static void union(int x, int y) {
+        if (x>y) parent[y] = x;
+        else parent[x] = y;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+            int c = Integer.parseInt(st.nextToken());
+            adj.add(new Node(a, b, c));
+        }
+
+        parent = new int[N + 1];
+        for (int i = 0; i < N + 1; i++) {
+            parent[i] = i;
+        }
+
+        adj.sort(Comparator.naturalOrder());
+
+        List<Integer> ans = new ArrayList<>();
+        for (Node node : adj) {
+            int p_u = find(node.u);
+            int p_v = find(node.v);
+            if (p_u != p_v) {
+                union(p_u, p_v);
+                ans.add(node.cost);
+            }
+        }
+
+        int mx = Integer.MIN_VALUE;
+        int sum = 0;
+        for (int x : ans) {
+            if (x > mx) mx = x;
+            sum+=x;
+        }
+        System.out.println(sum-mx);
+    }
+
+    static class Node implements Comparable<Node>{
+        int u;
+        int v;
+        int cost;
+
+        Node(int u, int v, int cost) {
+            this.u = u;
+            this.v = v;
+            this.cost = cost;
+        }
+
+        @Override
+        public int compareTo(Node o) {
+            return Integer.compare(this.cost, o.cost);
+        }
+    }
+}

BOJ/1000-10000번/SB_2531.java

@@ -0,0 +1,53 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+/*
+* 회전 초밥
+* 문제: 최대로 초밥먹을 수 있는 갯수 구하기
+* */
+public class SB_2531 {
+    static int N, D, K, C;
+    static int[] foods;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        D = Integer.parseInt(st.nextToken());
+        K = Integer.parseInt(st.nextToken());
+        C = Integer.parseInt(st.nextToken());
+
+        foods = new int[N];
+        for (int i = 0; i < N; i++) {
+            foods[i] = Integer.parseInt(br.readLine());
+        }
+
+        int left = 0;
+        int right = 0;
+        int mx = 0;
+
+        HashMap<Integer, Integer> eat = new HashMap<>();
+        eat.put(foods[left], 1);
+        while (left < N) {
+            while (right - left < K-1) {
+                right++;
+                if (foods[right%N]==C) continue;
+                eat.put(foods[right%N], eat.getOrDefault(foods[right%N], 0) + 1);
+            }
+            mx = Math.max(mx, eat.size());
+
+            eat.put(foods[left], eat.getOrDefault(foods[left], 0) - 1);
+            if (eat.get(foods[left]) <= 0) {
+                eat.remove(foods[left]);
+            }
+            left++;
+        }
+        System.out.println(mx+1);
+    }
+}
+
+/*
+* 회전초밥 일자가 아니라 원형으로 되어있음
+* */

BOJ/1000-10000번/SB_2631.java

@@ -0,0 +1,48 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+* 줄세우기
+* 문제: 최소한의 자리이동으로 정렬
+* 설계: N - 최장부분증가수열
+* */
+public class SB_2631 {
+    static int N;
+    static int[] line;
+    static List<Integer> lst = new ArrayList<>();
+
+    private static int findIdx(int x) {
+        int left = 0;
+        int right = lst.size()-1;
+
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (lst.get(mid) < x) left = mid+1;
+            else right = mid;
+        }
+        return left;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        N = Integer.parseInt(br.readLine());
+        line = new int[N];
+
+        for (int i = 0; i < N; i++) {
+            line[i] = Integer.parseInt(br.readLine());
+        }
+
+        // 이분탐색으로 최장부분증가수열 구하기
+        lst.add(line[0]);
+        for (int i=1; i<N; i++) {
+            if (line[i] > lst.get(lst.size() - 1)) lst.add(line[i]);
+            else {
+                int idx = findIdx(line[i]);
+                lst.set(idx, line[i]);
+            }
+        }
+        System.out.println(N-lst.size());
+    }
+}

BOJ/1000-10000번/SB_3020.java

@@ -0,0 +1,81 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+/*
+* 개똥벌레
+* 문제 설명: 석순, 종유석이 주어질때, 몇번째 라인으로 가야 개똥이가 최소 장애물 파괴하는지. 최소 장애물 파괴 수 + 해당 하는 구간의 갯수
+* 설계
+*   - 해당하는 구간의 갯수를 모두 구해야하기에 높이 H만큼 다 탐색해야함
+*   - N*H불가, logN 또는 N 시간복잡도로 해결하기 >> 투포인터? (: 반복 여러번일때 사용)
+*   - 종유석은(홀수) H-값 형태로 높이h에 위치하는지 확인
+*   - 순서 상관없이 특정 위치에서 부딪히는 갯수 일정 >> 정렬 가능
+* 구현
+*   - M번째에 위치할때 몇개 부딪히는지 구하기
+*       이분탐색으로 현재 리스트에서 i가 들어가야할 위치 찾기 (중복된 수 존재하니까 low-bound)
+*       전체 리스트 길이(M)-i == 부딪히는 갯수, (이때 리스트는 석순, 종유석 따로 관리)
+*   - 석순, 종유석 리스트 따로 구하기
+*       석순i에서 종유석의 위치는 H-i+1번째
+*       시간복잡도 이분탐색O(NlonN)*2N
+* */
+public class SB_3020 {
+    static int N, H, M;
+    static int[] down;
+    static int[] up;
+
+    private static int findIdx(int target, int[] lst) {
+        int left = 0;
+        int right = M;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (lst[mid] < target){     // low-bound, target이 존재할 제일 왼쪽반환 >> target 직전 작은값+1 위치
+                left = mid+1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        return right;
+    }
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        N = Integer.parseInt(st.nextToken());
+        H = Integer.parseInt(st.nextToken());
+
+        M = N/2;
+        // 석순, 종유석 리스트에 값 담기
+        down = new int[M];
+        up = new int[M];
+        for (int i = 0; i < N; i++) {
+            if (i%2==0) down[i / 2] = Integer.parseInt(br.readLine());
+            else up[(i - 1) / 2] = Integer.parseInt(br.readLine());
+        }
+
+        Arrays.sort(down);
+        Arrays.sort(up);
+
+        int mn = Integer.MAX_VALUE;
+        int cnt = 0;
+
+        // 각 층에서 부딪히는 갯수 구하기
+        for (int i = 1; i < H + 1; i++) {
+            int hitDown = M - findIdx(i, down);
+            int hitUp = M - findIdx(H - i + 1, up);
+
+            int totalHit = hitDown+hitUp;
+            if (totalHit < mn){
+                mn = totalHit;
+                cnt = 1;
+            } else if (totalHit==mn) cnt++;
+        }
+
+        System.out.println(mn + " " + cnt);
+    }
+}
+
+/*
+* 궁금증, 무한루프 방지를 위해 int mid = (left + (right-left)) / 2; 와 같이 적는걸로 아는데 이렇게 하면 무한루프 빠짐
+* */