231003

Author: NavyHubb

src/dateStructure/priorityQueue/BOJ_1655_가운데를말해요.java

@@ -0,0 +1,49 @@
+package dateStructure.priorityQueue;
+
+import java.util.Collections;
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+/**
+ * [조건]
+ * 지금까지 말한 수들 중에서의 중간값을 말해야 한다
+ * 외친 수가 짝수인 경우에는 중간에 있는 두 수 중 작은 값을 말한다
+ *
+ * [풀이]
+ * 우선순위 큐를 활용하여 최대힙과 최소힙을 각각 하나씩 마련한다
+ * 최소힙과 최대힙의 길이를 같게 유지하면서 입력값을 받는다
+ */
+public class BOJ_1655_가운데를말해요 {
+
+    static PriorityQueue<Integer> left;
+    static PriorityQueue<Integer> right;
+    static StringBuilder sb = new StringBuilder();
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        int N = sc.nextInt();
+
+        left = new PriorityQueue<>(Collections.reverseOrder());
+        right = new PriorityQueue<>();
+        for (int i = 0; i < N; i++) {
+            int n = sc.nextInt();
+
+            if (left.size() == right.size()) left.add(n);
+            else right.add(n);  // 두 힙의 길이가 다른 경우는 right의 길이가 더 짧은 경우밖에 없으므로 right에 채워준다
+
+            if (!left.isEmpty() && !right.isEmpty()) {
+                if (left.peek() > right.peek()) {
+                    int tmp = left.poll();
+                    left.add(right.poll());
+                    right.add(tmp);
+                }
+            }
+
+            sb.append(left.peek()).append('\n');
+        }
+
+        System.out.println(sb);
+    }
+
+}

src/dp/BOJ_7579_앱.java

@@ -0,0 +1,58 @@
+package dp;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ_7579_앱 {
+
+    static int N, M;
+    static int[][] apps;
+
+    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());  // 확보해야 하는 메모리
+        apps = new int[N+1][2];
+
+        st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < N; i++) {
+            apps[i+1][0] = Integer.parseInt(st.nextToken());
+        }
+
+        st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < N; i++) {
+            apps[i+1][1] = Integer.parseInt(st.nextToken());
+        }
+
+        System.out.println(solution());
+    }
+
+    static int solution() {
+        int result = Integer.MAX_VALUE;
+        int[][] dp = new int[2][10001];  // dp[i][c]: 1~i번째 앱을 고려하였을 때 비용 c로 확보할 수 있는 최대 메모리
+
+        for (int i = 1; i <= N; i++) {
+            int memory = apps[i][0];
+            int cost = apps[i][1];
+
+            for (int c = 0; c <= 10000; c++) {
+                if (c >= cost) {
+                    dp[i%2][c] = Math.max(memory + dp[(i-1)%2][c-cost], dp[(i-1)%2][c]);
+                } else {
+                    dp[i%2][c] = dp[(i-1)%2][c];
+                }
+
+                if (dp[i%2][c] >= M) {
+                    result = Math.min(result, c);
+                }
+            }
+        }
+
+        return result;
+    }
+
+}

src/graph/BOJ_14938_서강그라운드.java

@@ -0,0 +1,84 @@
+package graph;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+/**
+ * [조건]
+ * 예은이는 임의의 노드에 떨어진다
+ * 떨어진 노드에서 주어진 수색 범위 내(현재 위치 포함)의 아이템을 모두 얻게 된다
+ * 이때 얻을 수 있는 아이템 갯수의 최댓값을 구하라
+ *
+ * [풀이]
+ * 플로이드워셜을 통해 모든 노드에 대한 모든 노드로의 거리를 구하고
+ * 각 노드별로 얻을 수 있는 아이템 수를 구하여 그 중 최댓값을 구한다
+ */
+public class BOJ_14938_서강그라운드 {
+
+    static int V, E, R;
+    static int[] items;
+    static int[][] dist;
+    static final int INF = 1_000_000_000;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        V = Integer.parseInt(st.nextToken());  // 정점의 갯수
+        R = Integer.parseInt(st.nextToken());  // 범위의 크기
+        E = Integer.parseInt(st.nextToken());  // 간선의 갯수
+
+        st = new StringTokenizer(br.readLine());
+        items = new int[V+1];
+        for (int i = 1; i <= V; i++) {
+            items[i] = Integer.parseInt(st.nextToken());  // 노드 별 아이템의 갯수
+        }
+
+        // 거리 배열 초기화
+        dist = new int[V+1][V+1];
+        for (int i = 1; i <= V; i++) {
+            Arrays.fill(dist[i], INF);
+            dist[i][i] = 0;
+        }
+
+        for (int i = 0; i < E; i++) {
+            st = new StringTokenizer(br.readLine());
+
+            int from = Integer.parseInt(st.nextToken());
+            int to = Integer.parseInt(st.nextToken());
+            int weight = Integer.parseInt(st.nextToken());
+
+            dist[from][to] = weight;
+            dist[to][from] = weight;
+        }
+
+        System.out.println(solution());
+    }
+
+    static int solution() {
+        for (int k = 1; k <= V; k++) {
+            for (int i = 1; i <= V; i++) {
+                for (int j = 1; j <= V; j++) {
+                    if (dist[i][k] != INF && dist[k][j] != INF) {
+                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
+                    }
+                }
+            }
+        }
+
+        int[] result = new int[V+1];  // 노드 별 획득할 수 있는 아이템 갯수
+        for (int i = 1; i <= V; i++) {
+            for (int j = 1; j <= V; j++) {
+                if (dist[i][j] <= R) {  // 수색 범위 내에 있는 아이템 갯수 카운트
+                    result[i] += items[j];
+                }
+            }
+        }
+
+        return Arrays.stream(result).max().getAsInt();
+    }
+
+}

src/graph/BOJ_2589_보물섬.java

@@ -0,0 +1,90 @@
+package graph;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+/**
+ * [조건]
+ * 육지(L), 바다(W)
+ * 인접 상하좌우의 육지로만 이동 가능
+ * 보물은 서로 간에 최단 거리로 이동하는 데 있어 가장 긴 시간이 걸리는 육지 두 곳에 나뉘어 묻혀있다
+ *
+ * 지도가 주어질 때, 보물이 묻혀 있는 두 곳간의최단 거리로 이동하는 시간을 구하라
+ *
+ * [풀이]
+ * 모든 육지인 칸에 대해서 탐색하며
+ */
+public class BOJ_2589_보물섬 {
+
+    static int N, M;
+    static char[][] map;
+    static int[] di = {-1, 1, 0, 0};
+    static int[] dj = {0, 0, -1, 1};
+    static int result = 0;
+
+    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());
+
+        map = new char[N][M];
+        for (int i = 0; i < N; i++) {
+            String str = br.readLine();
+            for (int j = 0; j < M; j++) {
+                map[i][j] = str.charAt(j);
+            }
+        }
+
+        solution();
+        System.out.println(result);
+    }
+
+    static void solution() {
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                if (map[i][j] == 'L') {  // 육지
+                    bfs(i, j);
+                }
+            }
+        }
+    }
+
+    static void bfs(int startI, int startJ) {
+        int max = 0;
+
+        Queue<int[]> que = new LinkedList<>();
+        int[][] visited = new int[N][M];
+
+        que.add(new int[]{startI, startJ});
+        visited[startI][startJ] = 1;  // 방문하지 않은 곳과의 구분을 위해 0이 아닌 1로 초기화
+
+        while (!que.isEmpty()) {
+            int[] cur = que.poll();
+            int i = cur[0], j = cur[1];
+
+            for (int d = 0; d < 4; d++) {
+                int nextI = i + di[d];
+                int nextJ = j + dj[d];
+
+                if (nextI < 0 || nextJ < 0 || nextI > N-1 || nextJ > M-1) continue;
+                if (map[nextI][nextJ] != 'L') continue;
+                if (visited[nextI][nextJ] != 0) continue;
+
+                visited[nextI][nextJ] = visited[i][j] + 1;
+                que.add(new int[]{nextI, nextJ});
+
+                max = Math.max(max, visited[nextI][nextJ]);
+            }
+        }
+
+        // 최댓값 갱신
+        result = Math.max(result, max-1);
+    }
+
+}

src/greedy/BOJ_12904_A와B.java

@@ -0,0 +1,41 @@
+package greedy;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+/**
+ * 두 가지 연산
+ * - 문자열의 뒤에 A를 추가한다
+ * - 문자열을 뒤집고 뒤에 B를 추가한다
+ */
+public class BOJ_12904_A와B {
+
+    static StringBuffer S, T;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        S = new StringBuffer(br.readLine());
+        T = new StringBuffer(br.readLine());
+
+        System.out.println(solution());
+    }
+
+    static int solution() {
+        while (S.length() < T.length()) {
+            if (T.charAt(T.length()-1) == 'A') {
+                T.deleteCharAt(T.length()-1);
+            } else if (T.charAt(T.length()-1) == 'B') {
+                T.deleteCharAt(T.length()-1);
+                T.reverse();
+            }
+        }
+
+        if (S.toString().equals(T.toString())) {  // StringBuffer는 equals() 메서드를 override하지 않기 때문에 == 비교를 한 것과 같은 결과를 반환한다.
+            return 1;
+        }
+        return 0;
+    }
+
+}

src/greedy/BOJ_1343_폴리노미오.java

@@ -0,0 +1,63 @@
+package greedy;
+
+import java.util.Scanner;
+
+public class BOJ_1343_폴리노미오 {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        String s = sc.next();
+
+        StringBuilder sb = new StringBuilder();
+
+        String A = "AAAA";
+        String B = "BB";
+
+        int cnt = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == 'X') {
+                cnt++;
+            } else {
+                if (cnt%2 != 0) {
+                    System.out.println(-1);
+                    System.exit(0);
+                }
+
+                if (cnt > 0) {
+                    while (cnt >= 4) {
+                        sb.append(A);
+                        cnt -= 4;
+                    }
+
+                    while (cnt > 0 && cnt%2 == 0) {
+                        sb.append(B);
+                        cnt -= 2;
+                    }
+                }
+
+                sb.append('.');
+                cnt = 0;
+            }
+        }
+
+        if (cnt%2 != 0) {
+            System.out.println(-1);
+            System.exit(0);
+        }
+
+        if (cnt > 0) {
+            while (cnt >= 4) {
+                sb.append(A);
+                cnt -= 4;
+            }
+
+            while (cnt > 0 && cnt%2 == 0) {
+                sb.append(B);
+                cnt -= 2;
+            }
+        }
+
+        System.out.println(sb);
+    }
+
+}