Merge pull request #48 from KodaHye/main

baexxbin · web-flow · commit 0f3ec41d892c · 2024-10-06T10:44:23.000+09:00
[4주차] 고다혜
diff --git a/BOJ/1000-10000번/DH_1477.java b/BOJ/1000-10000번/DH_1477.java
@@ -0,0 +1,58 @@
+import java.io.*;
+import java.util.*;
+
+/*
+휴게소 세우기
+ */
+
+public class DH_1477 {
+    static int N, M, L;
+    static int[] arr;
+
+    static int binarySearch() {
+        int s = 1, e = L;
+
+        // lowerIdx 구해야 됨
+        while(s < e) {
+            int m = (s + e) / 2;
+
+            // m 길이 간격으로 휴게소 추가하기
+            // 휴게소 개수 구하기
+            int restCnt = getRestCnt(m);
+
+            // 추가할 수 있는 개수가  설치해야되는 개수보다 많다면, 길이 늘리기
+            if(restCnt > M) s = m + 1;
+            else e = m;
+        }
+
+        return s;
+    }
+
+    static int getRestCnt(int dis) {
+        int cnt = 0;
+        for(int i = 0; i < N + 1; i++) {
+            int current = i == N ? L: arr[i];
+            int prev = i == 0 ? 0: arr[i - 1];
+
+            cnt += ((current - prev - 1) / dis);
+        }
+
+        return cnt;
+    }
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+        L = Integer.parseInt(st.nextToken());
+
+        arr = new int[N];
+
+        st = new StringTokenizer(br.readLine());
+        for(int i = 0; i < N; i++) arr[i] = Integer.parseInt(st.nextToken());
+        Arrays.sort(arr);
+
+        System.out.println(binarySearch());
+    }
+}
diff --git a/BOJ/1000-10000번/DH_4386.java b/BOJ/1000-10000번/DH_4386.java
@@ -0,0 +1,115 @@
+import java.io.*;
+import java.util.*;
+
+/*
+별자리 만들기
+ */
+
+public class DH_4386 {
+    static class Point {
+        double r, c;
+        public Point(double r, double c) {
+            this.r = r;
+            this.c = c;
+        }
+    }
+
+    static class Edge {
+        int s, e;
+        double w;
+        public Edge(int s, int e, double w) {
+            this.s = s;
+            this.e = e;
+            this.w = w;
+        }
+    }
+
+    static int N;
+    static int[] p, rank;
+    static Point[] points;
+    static PriorityQueue<Edge> pq;
+
+    static void mst() {
+        int cnt = 0;
+        double result = 0;
+
+        while(!pq.isEmpty() && cnt < N - 1) {
+            Edge current = pq.poll();
+
+            if(find(current.e) == find(current.s)) continue;
+            union(current.e, current.s);
+            result += current.w;
+            cnt++;
+        }
+
+        System.out.println(((int) ((result * 100)) * 1.0) / 100);
+    }
+
+    // rank를 사용한 union
+    static void union(int a, int b) {
+        a = find(a);
+        b = find(b);
+
+        // rank가 작은 것을 큰 쪽으로 붙이기
+        if(rank[a] < rank[b]) p[a] = b;
+        else if(rank[a] > rank[b]) p[b] = a;
+        // rank가 같다면, 한 쪽 rank 늘려주고 거기에 붙이기
+        else {
+            p[b] = a;
+            rank[a]++;
+        }
+    }
+
+    // find: 경로 압축
+    static int find(int a) {
+        return p[a] = a == p[a] ? a: find(p[a]);
+    }
+
+    // 입력받은 별의 위치에 대해 모든 경우의 수를 pq에 넣어줌
+    static void setQ() {
+        for(int i = 0; i < points.length; i++) {
+            for(int j = i + 1; j < points.length; j++) {
+                pq.add(new Edge(i, j, getDis(i, j)));
+            }
+        }
+    }
+
+    // 두 별 사이 거리를 구하는 함수
+    static double getDis(int i, int j) {
+        double diffR = Math.pow(points[i].r - points[j].r, 2);
+        double diffC = Math.pow(points[i].c - points[j].c, 2);
+
+        return Math.sqrt(diffR + diffC);
+    }
+
+    public static void main(String[] args) throws Exception {
+        initInput();
+        setQ();
+        mst();
+    }
+
+    static void initInput() throws Exception {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        N = Integer.parseInt(br.readLine());
+
+        points = new Point[N];
+        p = new int[N];
+        rank = new int[N];
+
+//        pq = new PriorityQueue<>(Comparator.comparing(o -> o.w));
+//        pq = new PriorityQueue<>((o1, o2) -> Double.compare(o1.w, o2.w));
+        pq = new PriorityQueue<>(Comparator.comparingDouble(o -> o.w));
+
+        for(int i = 0; i < p.length; i++) p[i] = i;
+
+        for(int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            double r = Double.parseDouble(st.nextToken());
+            double c = Double.parseDouble(st.nextToken());
+
+            points[i] = new Point(r, c);
+        }
+    }
+}
diff --git a/BOJ/1000-10000번/DH_7570.java b/BOJ/1000-10000번/DH_7570.java
@@ -0,0 +1,28 @@
+import java.io.*;
+import java.util.*;
+
+/*
+줄세우기
+ */
+
+public class DH_7570 {
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+
+        int N = Integer.parseInt(br.readLine());
+        int[] dp = new int[N + 1];
+        int max = 0;
+
+        st = new StringTokenizer(br.readLine());
+        for(int i = 0; i < N; i++) {
+            int num = Integer.parseInt(st.nextToken());
+//            dp[num] = dp[num - 1] != 0 ? dp[num - 1] + 1 : 1;
+            dp[num] = dp[num - 1] + 1;
+            max = Math.max(dp[num], max);
+        }
+
+        System.out.println(N - max);
+
+    }
+}
diff --git a/CodeTree/2017-2018년/DH_토스트_계란틀.java b/CodeTree/2017-2018년/DH_토스트_계란틀.java
@@ -0,0 +1,99 @@
+import java.io.*;
+import java.util.*;
+
+/*
+토스트 계란틀
+ */
+
+public class DH_토스트_계란틀 {
+    static class Point {
+        int r, c;
+        public Point(int r, int c) {
+            this.r = r;
+            this.c = c;
+        }
+    }
+    static int N, L, R;
+    static int[][] map;
+    static boolean[][] v;
+    static int[] dr = {1, 0, -1, 0}, dc = {0, 1, 0, -1};
+    // tmp: 방문한 위치들을 저장할 임시 큐
+    static ArrayDeque<Point> q, tmp;
+
+    static void solution() {
+        int turn = 0;
+        while(canMove()) turn++;
+        System.out.println(turn);
+    }
+
+    static boolean canMove() {
+        v = new boolean[N][N];
+        boolean flag = false;
+
+        for(int r = 0; r < N; r++) {
+
+            int sum, cnt;
+            for(int c = 0; c < N; c++) {
+                if(v[r][c]) continue;
+                sum = map[r][c];
+                cnt = 1;
+
+                q.add(new Point(r, c));
+                tmp.add(new Point(r, c));
+                v[r][c] = true;
+                while(!q.isEmpty()) {
+                    Point current = q.poll();
+                    tmp.add(current);
+
+                    for(int d = 0; d < 4; d++) {
+                        int nr = current.r + dr[d];
+                        int nc = current.c + dc[d];
+
+                        if(!check(nr, nc) || v[nr][nc] || !isInRange(map[current.r][current.c], map[nr][nc])) continue;
+                        v[nr][nc] = true;
+                        q.add(new Point(nr, nc));
+                        sum += map[nr][nc];
+                        cnt++;
+                        flag = true;
+                    }
+                }
+
+                while(!tmp.isEmpty()) {
+                    Point current = tmp.poll();
+                    map[current.r][current.c] = sum / cnt;
+                }
+            }
+
+        }
+        return flag;
+    }
+
+    static boolean isInRange(int a, int b) {
+        return Math.abs(a - b) >= L && Math.abs(a - b) <= R;
+    }
+    static boolean check(int r, int c) {
+        return r >= 0 && r < N && c >= 0 && c < N;
+    }
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        L = Integer.parseInt(st.nextToken());
+        R = Integer.parseInt(st.nextToken());
+
+        map = new int[N][N];
+        q = new ArrayDeque<>();
+        tmp = new ArrayDeque<>();
+
+        for(int r = 0; r < N; r++) {
+            st = new StringTokenizer(br.readLine());
+            for(int c = 0; c < N; c++) {
+                map[r][c] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        solution();
+    }
+}
diff --git a/Programmers/Level2/DH_42885.java b/Programmers/Level2/DH_42885.java
@@ -0,0 +1,38 @@
+package Programmers.Level2;
+
+import java.util.*;
+
+/*
+구명보트
+ */
+
+public class DH_42885 {
+    class Solution {
+        public int solution(int[] people, int limit) {
+            int answer = 0;
+
+            Deque<Integer> q = new ArrayDeque<>();
+
+            Arrays.sort(people); // people 배열을 정렬 후 deque에 담음
+            for (int p : people) q.add(p);
+
+            while (!q.isEmpty()) { 
+                // pollLast를 하며 숫자가 큰 것부터 처리
+                int current = q.pollLast();
+                // 제한을 넘는다면 continue
+                if (current > limit) continue;
+
+                answer++;
+
+                if (!q.isEmpty()) {
+                    // 큐에 있는 제일 큰 값과, 제일 작은 값을 비교하며
+                    // 구명보트 태우기
+                    if (current + q.peekLast() <= limit) q.pollLast();
+                    else if (current + q.peekFirst() <= limit) q.pollFirst();
+                }
+
+            }
+            return answer;
+        }
+    }
+}
diff --git a/Programmers/Level3/DH_42898.java b/Programmers/Level3/DH_42898.java
@@ -0,0 +1,41 @@
+package Programmers.Level3;
+
+/*
+등굣길
+ */
+
+class DH_42898 {
+    static final int MOD = 1_000_000_007;
+    static int[] dr = {0, -1}, dc = {-1, 0};
+    static int[][] dp; // 해당 지점까지 갈 수 있는 경우의 수를 저장하는 변수
+    static boolean[][] existPuddle; // 물에 잠긴 지역 확이하는 변수
+
+    static boolean check(int r, int c) {
+        return r >= 0 && r < dp.length && c >= 0 && c < dp[0].length;
+    }
+
+    public int solution(int m, int n, int[][] puddles) {
+        existPuddle = new boolean[n][m];
+
+        // 물에 잠긴 지역 체크
+        for(int[] p: puddles) existPuddle[p[1] - 1][p[0] - 1] = true;
+
+        dp = new int[n][m];
+
+        dp[0][0] = 1;
+        for(int r = 0; r < n; r++) {
+            for(int c = 0; c < m; c++) {
+                for(int d = 0; d < 2; d++) {
+                    int prevR = r + dr[d];
+                    int prevC = c + dc[d];
+
+                    // 해당 지점 기준 가능한 이전 지점에서의 가지수 더해주기
+                    if(!check(prevR, prevC) || existPuddle[prevR][prevC]) continue;
+                    dp[r][c] = (dp[r][c] + dp[prevR][prevC]) % MOD;
+                }
+            }
+        }
+
+        return dp[n - 1][m - 1];
+    }
+}
diff --git a/SQL/3주차/DH_대장균의 자식의 수 구하기.sql b/SQL/3주차/DH_대장균의 자식의 수 구하기.sql
diff --git a/SQL/3주차/DH_물고기 종류 별 대어 찾기.sql b/SQL/3주차/DH_물고기 종류 별 대어 찾기.sql
diff --git a/SQL/4주차/DH_노선별 평균 역 사이 거리 조회하기.sql b/SQL/4주차/DH_노선별 평균 역 사이 거리 조회하기.sql
@@ -0,0 +1,9 @@
+# https://school.programmers.co.kr/learn/courses/30/lessons/284531
+# ROUND(숫자, 1): 소숫점 아래 두 번째 자리에서 반올림해서 첫번째까지만 보이기
+# CONCAT(STR1, STR2): 두 개의 문자 붙이기
+SELECT ROUTE
+     , CONCAT(ROUND(SUM(D_BETWEEN_DIST), 1), 'km') `TOTAL_DISTANCE`
+     , CONCAT(ROUND(AVG(D_BETWEEN_DIST), 2), 'km') `AVERAGE_DISTANCE`
+FROM SUBWAY_DISTANCE
+GROUP BY ROUTE
+ORDER BY ROUND(SUM(D_BETWEEN_DIST), 1) DESC
diff --git a/SQL/4주차/대장균의 크기에 따라 분류하기 1.sql b/SQL/4주차/대장균의 크기에 따라 분류하기 1.sql
