diff --git "a/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/README.md" "b/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/README.md" new file mode 100644 index 00000000..b99adbb3 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/README.md" @@ -0,0 +1,38 @@ +# [Gold V] 빗물 - 14719 + +[문제 링크](https://www.acmicpc.net/problem/14719) + +### 성능 요약 + +메모리: 11864 KB, 시간: 72 ms + +### 분류 + +구현, 시뮬레이션 + +### 제출 일자 + +2025년 5월 7일 20:59:07 + +### 문제 설명 + +

2차원 세계에 블록이 쌓여있다. 비가 오면 블록 사이에 빗물이 고인다.

+ +

+ +

비는 충분히 많이 온다. 고이는 빗물의 총량은 얼마일까?

+ +### 입력 + +

첫 번째 줄에는 2차원 세계의 세로 길이 H과 2차원 세계의 가로 길이 W가 주어진다. (1 ≤ H, W ≤ 500)

+ +

두 번째 줄에는 블록이 쌓인 높이를 의미하는 0이상 H이하의 정수가 2차원 세계의 맨 왼쪽 위치부터 차례대로 W개 주어진다.

+ +

따라서 블록 내부의 빈 공간이 생길 수 없다. 또 2차원 세계의 바닥은 항상 막혀있다고 가정하여도 좋다.

+ +### 출력 + +

2차원 세계에서는 한 칸의 용량은 1이다. 고이는 빗물의 총량을 출력하여라.

+ +

빗물이 전혀 고이지 않을 경우 0을 출력하여라.

+ diff --git "a/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/\353\271\227\353\254\274.java" "b/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/\353\271\227\353\254\274.java" new file mode 100644 index 00000000..887175e3 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/14719.\342\200\205\353\271\227\353\254\274/\353\271\227\353\254\274.java" @@ -0,0 +1,65 @@ +import java.util.*; +import java.io.*; + +public class Main { + static Deque q; + static int result; + + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + int H = Integer.parseInt(st.nextToken()); + int W = Integer.parseInt(st.nextToken()); + + st = new StringTokenizer(br.readLine()); + + q = new ArrayDeque<>(); + result = 0; + for (int i = 0; i < W; i++) { + int curr = Integer.parseInt(st.nextToken()); + if (q.isEmpty()) { + q.offer(curr); + continue; + } + + if (q.peekFirst() <= curr) { + calc(); + q.offer(curr); + continue; + } else { + q.offer(curr); + } + } + lastCalc(); + + System.out.println(result); + } + + static void calc() { + int high = q.poll(); + while (!q.isEmpty()) { + int curr = q.poll(); + result += high - curr; + } + } + + static void lastCalc() { + if (!q.isEmpty()) + q.poll(); + + while (!q.isEmpty()) { + int maxHeight = 0; + for (int i : q) { + maxHeight = Math.max(maxHeight, i); + } + while (true) { + int curr = q.poll(); + if (curr == maxHeight) { + break; + } + result += maxHeight - curr; + } + } + + } +} diff --git "a/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/README.md" "b/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/README.md" new file mode 100644 index 00000000..5a874045 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/README.md" @@ -0,0 +1,28 @@ +# [Gold IV] 부분합 - 1806 + +[문제 링크](https://www.acmicpc.net/problem/1806) + +### 성능 요약 + +메모리: 23144 KB, 시간: 192 ms + +### 분류 + +누적 합, 두 포인터 + +### 제출 일자 + +2025년 5월 10일 13:44:35 + +### 문제 설명 + +

10,000 이하의 자연수로 이루어진 길이 N짜리 수열이 주어진다. 이 수열에서 연속된 수들의 부분합 중에 그 합이 S 이상이 되는 것 중, 가장 짧은 것의 길이를 구하는 프로그램을 작성하시오.

+ +### 입력 + +

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는 공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

+ +### 출력 + +

첫째 줄에 구하고자 하는 최소의 길이를 출력한다. 만일 그러한 합을 만드는 것이 불가능하다면 0을 출력하면 된다.

+ diff --git "a/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/\353\266\200\353\266\204\355\225\251.java" "b/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/\353\266\200\353\266\204\355\225\251.java" new file mode 100644 index 00000000..f2904ba2 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1806.\342\200\205\353\266\200\353\266\204\355\225\251/\353\266\200\353\266\204\355\225\251.java" @@ -0,0 +1,35 @@ +import java.util.*; +import java.io.*; + +public class Main { + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + int N = Integer.parseInt(st.nextToken()); + int S = Integer.parseInt(st.nextToken()); + + int[] arr = new int[N+1]; + int[] prefix = new int[N+1]; + + st = new StringTokenizer(br.readLine()); + for(int i = 1; i <= N; i++) { + arr[i] = Integer.parseInt(st.nextToken()); + prefix[i] = prefix[i-1] + arr[i]; + } + + int left = 0; + int right = 1; + int result = Integer.MAX_VALUE; + boolean flag = false; + while(right <= N) { + if (prefix[right] - prefix[left] >= S) { + flag = true; + result = Math.min(result, right - left); + left++; + continue; + } + right++; + } + System.out.println(flag ? result : 0); + } +} \ No newline at end of file diff --git "a/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/README.md" "b/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/README.md" new file mode 100644 index 00000000..d2737245 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/README.md" @@ -0,0 +1,30 @@ +# [Gold IV] 스카이라인 쉬운거 - 1863 + +[문제 링크](https://www.acmicpc.net/problem/1863) + +### 성능 요약 + +메모리: 17256 KB, 시간: 136 ms + +### 분류 + +자료 구조, 스택 + +### 제출 일자 + +2025년 5월 5일 18:01:42 + +### 문제 설명 + +

도시에서 태양이 질 때에 보이는 건물들의 윤곽을 스카이라인이라고 한다. 스카이라인만을 보고서 도시에 세워진 건물이 몇 채인지 알아 낼 수 있을까? 건물은 모두 직사각형 모양으로 밋밋하게 생겼다고 가정한다.

+ +

정확히 건물이 몇 개 있는지 알아내는 것은 대부분의 경우에 불가능하고, 건물이 최소한 몇 채 인지 알아내는 것은 가능해 보인다. 이를 알아내는 프로그램을 작성해 보자.

+ +### 입력 + +

첫째 줄에 n이 주어진다. (1 ≤ n ≤ 50,000) 다음 n개의 줄에는 왼쪽부터 스카이라인을 보아 갈 때 스카이라인의 고도가 바뀌는 지점의 좌표 x와 y가 주어진다. (1 ≤ x ≤ 1,000,000. 0 ≤ y ≤ 500,000) 첫 번째 지점의 x좌표는 항상 1이다.

+ +### 출력 + +

첫 줄에 최소 건물 개수를 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260.java" "b/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260.java" new file mode 100644 index 00000000..f832ae9f --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1863.\342\200\205\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260/\354\212\244\354\271\264\354\235\264\353\235\274\354\235\270\342\200\205\354\211\254\354\232\264\352\261\260.java" @@ -0,0 +1,36 @@ +import java.io.*; +import java.util.*; + +public class Main { + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + + int N = Integer.parseInt(br.readLine()); + + int result = 0; + + Deque q = new ArrayDeque<>(); + q.offer(0); // 기초값 0 + for(int i = 0; i < N; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int x = Integer.parseInt(st.nextToken()); + int y = Integer.parseInt(st.nextToken()); + if (y > q.peekLast()) { + q.offerLast(y); + } else { + while(y < q.peekLast()) { + q.pollLast(); + result++; + } + } + if (y != q.peekLast()) + q.offerLast(y); + } + while (!q.isEmpty() && q.peekLast() != 0) { + q.pollLast(); + result++; + } + + System.out.println(result); + } +} \ No newline at end of file diff --git "a/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/README.md" "b/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/README.md" new file mode 100644 index 00000000..cc387c65 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/README.md" @@ -0,0 +1,38 @@ +# [Gold IV] 트리의 지름 - 1967 + +[문제 링크](https://www.acmicpc.net/problem/1967) + +### 성능 요약 + +메모리: 21248 KB, 시간: 172 ms + +### 분류 + +그래프 이론, 그래프 탐색, 트리, 깊이 우선 탐색, 트리의 지름 + +### 제출 일자 + +2025년 5월 13일 20:46:16 + +### 문제 설명 + +

트리(tree)는 사이클이 없는 무방향 그래프이다. 트리에서는 어떤 두 노드를 선택해도 둘 사이에 경로가 항상 하나만 존재하게 된다. 트리에서 어떤 두 노드를 선택해서 양쪽으로 쫙 당길 때, 가장 길게 늘어나는 경우가 있을 것이다. 이럴 때 트리의 모든 노드들은 이 두 노드를 지름의 끝 점으로 하는 원 안에 들어가게 된다.

+ +

+ +

이런 두 노드 사이의 경로의 길이를 트리의 지름이라고 한다. 정확히 정의하자면 트리에 존재하는 모든 경로들 중에서 가장 긴 것의 길이를 말한다.

+ +

입력으로 루트가 있는 트리를 가중치가 있는 간선들로 줄 때, 트리의 지름을 구해서 출력하는 프로그램을 작성하시오. 아래와 같은 트리가 주어진다면 트리의 지름은 45가 된다.

+ +

+ +

트리의 노드는 1부터 n까지 번호가 매겨져 있다.

+ +### 입력 + +

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다. 둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다. 간선에 대한 정보는 세 개의 정수로 이루어져 있다. 첫 번째 정수는 간선이 연결하는 두 노드 중 부모 노드의 번호를 나타내고, 두 번째 정수는 자식 노드를, 세 번째 정수는 간선의 가중치를 나타낸다. 간선에 대한 정보는 부모 노드의 번호가 작은 것이 먼저 입력되고, 부모 노드의 번호가 같으면 자식 노드의 번호가 작은 것이 먼저 입력된다. 루트 노드의 번호는 항상 1이라고 가정하며, 간선의 가중치는 100보다 크지 않은 양의 정수이다.

+ +### 출력 + +

첫째 줄에 트리의 지름을 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204.java" "b/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204.java" new file mode 100644 index 00000000..97e403bc --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/1967.\342\200\205\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204/\355\212\270\353\246\254\354\235\230\342\200\205\354\247\200\353\246\204.java" @@ -0,0 +1,68 @@ +import java.io.*; +import java.util.*; + +public class Main { + static boolean[] isVisited; + static ArrayList[] tree; + static int result; + static int farNode; + + static class Edge { + int to; + int weight; + + Edge(int to, int weight) { + this.to = to; + this.weight = weight; + } + } + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int n = Integer.parseInt(br.readLine()); + if (n == 1) { + System.out.println(0); + return; + } + isVisited = new boolean[n + 1]; + tree = new ArrayList[n + 1]; + + for (int i = 1; i <= n; i++) { + tree[i] = new ArrayList<>(); + } + + for (int i = 1; i < n; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int a = Integer.parseInt(st.nextToken()); + int b = Integer.parseInt(st.nextToken()); + int c = Integer.parseInt(st.nextToken()); + + tree[a].add(new Edge(b, c)); + tree[b].add(new Edge(a, c)); + } + + Arrays.fill(isVisited, false); + dfs(1, 0); + + Arrays.fill(isVisited, false); + result = 0; + dfs(farNode, 0); + + System.out.println(result); + } + + static void dfs(int node, int cost) { + isVisited[node] = true; + + if (cost > result) { + result = cost; + farNode = node; + } + + for (Edge e : tree[node]) { + if (!isVisited[e.to]) { + dfs(e.to, cost + e.weight); + } + } + } +} diff --git "a/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/README.md" "b/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/README.md" new file mode 100644 index 00000000..971b2b30 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/README.md" @@ -0,0 +1,52 @@ +# [Gold V] 컨베이어 벨트 위의 로봇 - 20055 + +[문제 링크](https://www.acmicpc.net/problem/20055) + +### 성능 요약 + +메모리: 13484 KB, 시간: 212 ms + +### 분류 + +구현, 시뮬레이션 + +### 제출 일자 + +2025년 5월 6일 03:35:18 + +### 문제 설명 + +

길이가 N인 컨베이어 벨트가 있고, 길이가 2N인 벨트가 이 컨베이어 벨트를 위아래로 감싸며 돌고 있다. 벨트는 길이 1 간격으로 2N개의 칸으로 나뉘어져 있으며, 각 칸에는 아래 그림과 같이 1부터 2N까지의 번호가 매겨져 있다.

+ +

+ +

벨트가 한 칸 회전하면 1번부터 2N-1번까지의 칸은 다음 번호의 칸이 있는 위치로 이동하고, 2N번 칸은 1번 칸의 위치로 이동한다. i번 칸의 내구도는 Ai이다. 위의 그림에서 1번 칸이 있는 위치를 "올리는 위치", N번 칸이 있는 위치를 "내리는 위치"라고 한다.

+ +

컨베이어 벨트에 박스 모양 로봇을 하나씩 올리려고 한다. 로봇은 올리는 위치에만 올릴 수 있다. 언제든지 로봇이 내리는 위치에 도달하면 그 즉시 내린다. 로봇은 컨베이어 벨트 위에서 스스로 이동할 수 있다. 로봇을 올리는 위치에 올리거나 로봇이 어떤 칸으로 이동하면 그 칸의 내구도는 즉시 1만큼 감소한다.

+ +

컨베이어 벨트를 이용해 로봇들을 건너편으로 옮기려고 한다. 로봇을 옮기는 과정에서는 아래와 같은 일이 순서대로 일어난다.

+ +
    +
+ +
    +
  1. 벨트가 각 칸 위에 있는 로봇과 함께 한 칸 회전한다.
    2. +
  2. 가장 먼저 벨트에 올라간 로봇부터, 벨트가 회전하는 방향으로 한 칸 이동할 수 있다면 이동한다. 만약 이동할 수 없다면 가만히 있는다. +
      +
    1. 로봇이 이동하기 위해서는 이동하려는 칸에 로봇이 없으며, 그 칸의 내구도가 1 이상 남아 있어야 한다.
      2. +
    +
    3. +
  3. 올리는 위치에 있는 칸의 내구도가 0이 아니면 올리는 위치에 로봇을 올린다.
    4. +
  4. 내구도가 0인 칸의 개수가 K개 이상이라면 과정을 종료한다. 그렇지 않다면 1번으로 돌아간다.
    5. +
+ +

종료되었을 때 몇 번째 단계가 진행 중이었는지 구해보자. 가장 처음 수행되는 단계는 1번째 단계이다.

+ +### 입력 + +

첫째 줄에 N, K가 주어진다. 둘째 줄에는 A1, A2, ..., A2N이 주어진다.

+ +### 출력 + +

몇 번째 단계가 진행 중일때 종료되었는지 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207.java" "b/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207.java" new file mode 100644 index 00000000..7af8735d --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20055.\342\200\205\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207/\354\273\250\353\262\240\354\235\264\354\226\264\342\200\205\353\262\250\355\212\270\342\200\205\354\234\204\354\235\230\342\200\205\353\241\234\353\264\207.java" @@ -0,0 +1,77 @@ +import java.io.*; +import java.util.*; + +public class Main { + static int N, K; + static int[] belt; + static boolean[] robot; + static int result; + + 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()); + K = Integer.parseInt(st.nextToken()); + + belt = new int[2 * N]; + robot = new boolean[N]; + result = 0; + + st = new StringTokenizer(br.readLine()); + for (int i = 0; i < 2 * N; i++) { + belt[i] = Integer.parseInt(st.nextToken()); + } + + while (true) { + result++; + + rotate(); + moveRobot(); + loadRobot(); + + if (!check()) break; + } + + System.out.println(result); + } + + static void rotate() { + int last = belt[2 * N - 1]; + for (int i = 2 * N - 1; i > 0; i--) { + belt[i] = belt[i - 1]; + } + belt[0] = last; + + for (int i = N - 1; i > 0; i--) { + robot[i] = robot[i - 1]; + } + robot[0] = false; + robot[N - 1] = false; + } + + static void moveRobot() { + for (int i = N - 2; i >= 0; i--) { + if (robot[i] && !robot[i + 1] && belt[i + 1] > 0) { + robot[i] = false; + robot[i + 1] = true; + belt[i + 1]--; + } + } + robot[N - 1] = false; + } + + static void loadRobot() { + if (belt[0] > 0) { + robot[0] = true; + belt[0]--; + } + } + + static boolean check() { + int count = 0; + for (int i = 0; i < 2 * N; i++) { + if (belt[i] == 0) count++; + } + return count < K; + } +} diff --git "a/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/README.md" "b/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/README.md" new file mode 100644 index 00000000..db81c564 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/README.md" @@ -0,0 +1,36 @@ +# [Gold IV] 동작 그만. 밑장 빼기냐? - 20159 + +[문제 링크](https://www.acmicpc.net/problem/20159) + +### 성능 요약 + +메모리: 23948 KB, 시간: 204 ms + +### 분류 + +누적 합 + +### 제출 일자 + +2025년 5월 12일 01:18:12 + +### 문제 설명 + +

싸늘하다. 정훈이는 다음과 같은 도박을 하고 있다.

+ +

N개의 카드와 2명의 플레이어가 있다. 플레이어가 자신과 상대방에게 번갈아 가며 카드의 윗장부터 한 장씩 분배한다. 단, 카드는 분배한 사람부터 받는다. 카드를 모두 분배했을 때 카드에 적힌 수의 합이 더 큰 사람이 이긴다. 두 명이 공평하게 카드를 나눠 갖기 위해 카드의 개수는 짝수로 주어진다.

+ +

카드를 섞고 있는 정훈이는 타짜다. 수없이 많이 카드를 섞어본 경험으로 섞고 난 후 카드의 값들을 다 알고 있다. 정훈이에게 카드를 분배할 수 있는 기회가 왔다. 확실한 승리를 위해 카드를 분배할 때 카드의 윗장이 아닌 밑장을 빼는 밑장 빼기를 하기로 마음을 먹었다. 상대는 눈치가 빠르기로 유명한 선수이므로 밑장 빼기는 최대 한번 할 것이다.

+ +

정훈이가 최대 한번 밑장 빼기를 할 때 얻을 수 있는 최대 카드의 합을 구하여라.

+ +### 입력 + +

카드의 개수 N (2 ≤ N ≤ 100,000)이 주어진다. 단, N은 짝수이다.

+ +

둘째 줄에 카드의 윗장부터 밑장까지 카드의 값 X (1 ≤ X ≤ 10,000)이 정수로 주어진다.

+ +### 출력 + +

정훈이가 얻을 수 있는 최대 카드 값의 합을 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237.java" "b/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237.java" new file mode 100644 index 00000000..ec2f2984 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20159.\342\200\205\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237/\353\217\231\354\236\221\342\200\205\352\267\270\353\247\214\357\274\216\342\200\205\353\260\221\354\236\245\342\200\205\353\271\274\352\270\260\353\203\220\357\274\237.java" @@ -0,0 +1,74 @@ +import java.io.*; +import java.util.*; + +public class Main { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int N = Integer.parseInt(br.readLine()); + int[] arr = new int[N]; + int[] A = new int[N + 1]; + int[] B = new int[N + 1]; + int[] prefixA = new int[N + 1]; + + StringTokenizer st = new StringTokenizer(br.readLine()); + for (int i = 0; i < N; i++) { + arr[i] = Integer.parseInt(st.nextToken()); + } + + for (int i = 0; i < N; i++) { + if (i == 0) { + prefixA[i] = arr[i]; + continue; + } + if (i % 2 == 0) { + prefixA[i] = prefixA[i - 1] + arr[i]; + } else { + prefixA[i] = prefixA[i - 1]; + } + } + + for (int i = N - 1; i >= 0; i--) { + if (i == N - 1 || i == N - 2) { + if (i % 2 == 0) { + A[i] = 0 + arr[i]; + B[i] = B[i + 1]; + } else { + A[i] = A[i + 1]; + B[i] = 0 + arr[i]; + } + continue; + } + if (i % 2 == 0) { + A[i] = A[i + 1] + arr[i]; + B[i] = B[i + 1]; + } else { + A[i] = A[i + 1]; + B[i] = B[i + 1] + arr[i]; + } + } + +// for (int i : A) { +// System.out.print(i + " "); +// } +// System.out.println(); +// for (int i : B) { +// System.out.print(i + " "); +// } +// System.out.println(); + + int result = A[0]; + for (int i = 0; i < N; i++) { + if (i == 0) { + result = Math.max(result, B[i]); + continue; + } + if (i % 2 == 0) { + result = Math.max(result, prefixA[i - 1] + B[i]); + } else if (i % 2 != 0) { + result = Math.max(result, prefixA[i] + B[i] - arr[N - 1]); + } + } + System.out.println(result); + + } +} diff --git "a/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/README.md" "b/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/README.md" new file mode 100644 index 00000000..29f6fecb --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/README.md" @@ -0,0 +1,41 @@ +# [Gold V] 문자열 게임 2 - 20437 + +[문제 링크](https://www.acmicpc.net/problem/20437) + +### 성능 요약 + +메모리: 28952 KB, 시간: 244 ms + +### 분류 + +슬라이딩 윈도우, 문자열 + +### 제출 일자 + +2025년 5월 10일 18:49:25 + +### 문제 설명 + +

작년에 이어 새로운 문자열 게임이 있다. 게임의 진행 방식은 아래와 같다.

+ +
    +
  1. 알파벳 소문자로 이루어진 문자열 W가 주어진다.
    2. +
  2. 양의 정수 K가 주어진다.
    3. +
  3. 어떤 문자를 정확히 K개를 포함하는 가장 짧은 연속 문자열의 길이를 구한다.
    4. +
  4. 어떤 문자를 정확히 K개를 포함하고, 문자열의 첫 번째와 마지막 글자가 해당 문자로 같은 가장 긴 연속 문자열의 길이를 구한다.
    5. +
+ +

위와 같은 방식으로 게임을 T회 진행한다.

+ +### 입력 + +

문자열 게임의 수 T가 주어진다. (1 ≤ T ≤ 100)

+ +

다음 줄부터 2개의 줄 동안 문자열 W와 정수 K가 주어진다. (1 ≤ K ≤ |W| ≤ 10,000)

+ +### 출력 + +

T개의 줄 동안 문자열 게임의 3번과 4번에서 구한 연속 문자열의 길이를 공백을 사이에 두고 출력한다.

+ +

만약 만족하는 연속 문자열이 없을 시 -1을 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052.java" "b/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052.java" new file mode 100644 index 00000000..746e4954 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20437.\342\200\205\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052/\353\254\270\354\236\220\354\227\264\342\200\205\352\262\214\354\236\204\342\200\2052.java" @@ -0,0 +1,43 @@ +import java.io.*; +import java.util.*; + +public class Main { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int T = Integer.parseInt(br.readLine()); + for (int t = 0; t < T; t++) { + String s = br.readLine(); + int K = Integer.parseInt(br.readLine()); + + int minArr = 10001; + int maxArr = 0; + boolean flag = false; + + Deque[] arr = new ArrayDeque[26]; + for (int i = 0; i < 26; i++) { + arr[i] = new ArrayDeque<>(); + } + + for (int j = 0; j < s.length(); j++) { + int curr = s.charAt(j) - 'a'; + arr[curr].offer(j); + if (arr[curr].size() > K) { + arr[curr].pollFirst(); + } + if (arr[curr].size() == K) { + flag = true; + int diff = arr[curr].peekLast() - arr[curr].peekFirst() + 1; + minArr = Math.min(minArr, diff); + maxArr = Math.max(maxArr, diff); + } + } + + if (flag) { + System.out.println(minArr + " " + maxArr); + } else { + System.out.println(-1); + } + + } + } +} diff --git "a/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/README.md" "b/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/README.md" new file mode 100644 index 00000000..09d55420 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/README.md" @@ -0,0 +1,44 @@ +# [Gold III] 🎵니가 싫어 싫어 너무 싫어 싫어 오지 마 내게 찝쩍대지마🎵 - 1 - 20440 + +[문제 링크](https://www.acmicpc.net/problem/20440) + +### 성능 요약 + +메모리: 344064 KB, 시간: 740 ms + +### 분류 + +값 / 좌표 압축, 누적 합, 정렬, 스위핑 + +### 제출 일자 + +2025년 5월 10일 17:32:29 + +### 문제 설명 + +
+

🎵니가 싫어 싫어 너무 싫어 싫어 오지마 내게 찝쩍대지마🎵 - 유자, 모기송 中

+
+ +

모기를 싫어하는 지동이는 어느 날 문득 자신의 방에 모기가 가장 많이 있는 시간대가 언제인지 궁금해졌다. 다행히 지동이 방은 최첨단 시스템이 갖춰져 있어 어떤 모기가 방에 언제 입장했고 언제 퇴장했는지를 기록할 수 있다.

+ +

지동이를 도와 모기들의 방 입장, 퇴장 시각이 주어졌을 때 모기들이 가장 많이 있는 시간대와 해당 시간대에 모기가 몇 마리가 있는지 구하는 프로그램을 만들어보자.

+ +### 입력 + +

첫째 줄에 지동이의 방에 출입한 모기의 마릿수 N(1 ≤ N ≤ 1,000,000)가 주어진다.

+ +

다음 N개의 줄에 모기의 입장 시각 TE과 퇴장 시각 TX이 주어진다. (0 ≤ TE < TX ≤ 2,100,000,000)

+ +

모기는 [TE, Tx)동안 존재한다.

+ +

+ +### 출력 + +

첫째 줄에 지동이 방에 모기가 가장 많이 있는 시간대의 모기 마릿수를 출력한다.

+ +

지동이 방에 모기가 가장 많이 있는 시간대의 연속 구간 전체를 [TEm, TXm)이라고 할 때,

+ +

둘째 줄에 TEm, TXm을 공백으로 구분하여 출력한다. 단, 여러 가지 방법이 있으면 가장 빠른 시작 시각을 기준으로 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051.java" "b/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051.java" new file mode 100644 index 00000000..cb86deb5 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/20440.\342\200\205\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051/\360\237\216\265\353\213\210\352\260\200\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\353\204\210\353\254\264\342\200\205\354\213\253\354\226\264\342\200\205\354\213\253\354\226\264\342\200\205\354\230\244\354\247\200\342\200\205\353\247\210\342\200\205\353\202\264\352\262\214\342\200\205\354\260\235\354\251\215\353\214\200\354\247\200\353\247\210\360\237\216\265\342\200\205\357\274\215\342\200\2051.java" @@ -0,0 +1,68 @@ +import java.io.*; +import java.util.*; + +public class Main { + static class Event implements Comparable { + int time; + int delta; // 입장: +1, 퇴장: -1 + + Event(int time, int delta) { + this.time = time; + this.delta = delta; + } + + @Override + public int compareTo(Event o) { + if (this.time == o.time) return this.delta - o.delta; // 입장 먼저 처리 + return this.time - o.time; + } + } + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int N = Integer.parseInt(br.readLine()); + List events = new ArrayList<>(); + + for (int i = 0; i < N; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int enter = Integer.parseInt(st.nextToken()); + int exit = Integer.parseInt(st.nextToken()); + + events.add(new Event(enter, 1)); // 입장 + events.add(new Event(exit, -1)); // 퇴장 + } + + Collections.sort(events); + + int current = 0; + int maxCount = 0; + int startTime = 0; + int endTime = 0; + boolean tracking = false; + + int i = 0; + while (i < events.size()) { + int time = events.get(i).time; + + while (i < events.size() && events.get(i).time == time) { + current += events.get(i).delta; + i++; + } + + if (current > maxCount) { + maxCount = current; + startTime = time; + endTime = time; + tracking = true; + } else if (current < maxCount && tracking) { + endTime = time; + tracking = false; + } else if (current == maxCount && tracking) { + endTime = time; + } + } + + System.out.println(maxCount); + System.out.println(startTime + " " + endTime); + } +} diff --git "a/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/README.md" "b/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/README.md" new file mode 100644 index 00000000..219fad95 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/README.md" @@ -0,0 +1,44 @@ +# [Gold V] 개똥벌레 - 3020 + +[문제 링크](https://www.acmicpc.net/problem/3020) + +### 성능 요약 + +메모리: 32248 KB, 시간: 236 ms + +### 분류 + +이분 탐색, 누적 합 + +### 제출 일자 + +2025년 5월 12일 22:51:00 + +### 문제 설명 + +

개똥벌레 한 마리가 장애물(석순과 종유석)로 가득찬 동굴에 들어갔다. 동굴의 길이는 N미터이고, 높이는 H미터이다. (N은 짝수) 첫 번째 장애물은 항상 석순이고, 그 다음에는 종유석과 석순이 번갈아가면서 등장한다.

+ +

아래 그림은 길이가 14미터이고 높이가 5미터인 동굴이다. (예제 그림)

+ +

+ +

이 개똥벌레는 장애물을 피하지 않는다. 자신이 지나갈 구간을 정한 다음 일직선으로 지나가면서 만나는 모든 장애물을 파괴한다.

+ +

위의 그림에서 4번째 구간으로 개똥벌레가 날아간다면 파괴해야하는 장애물의 수는 총 여덟개이다. (4번째 구간은 길이가 3인 석순과 길이가 4인 석순의 중간지점을 말한다)

+ +

+ +

하지만, 첫 번째 구간이나 다섯 번째 구간으로 날아간다면 개똥벌레는 장애물 일곱개만 파괴하면 된다.

+ +

동굴의 크기와 높이, 모든 장애물의 크기가 주어진다. 이때, 개똥벌레가 파괴해야하는 장애물의 최솟값과 그러한 구간이 총 몇 개 있는지 구하는 프로그램을 작성하시오.

+ +### 입력 + +

첫째 줄에 N과 H가 주어진다. N은 항상 짝수이다. (2 ≤ N ≤ 200,000, 2 ≤ H ≤ 500,000)

+ +

다음 N개 줄에는 장애물의 크기가 순서대로 주어진다. 장애물의 크기는 H보다 작은 양수이다.

+ +### 출력 + +

첫째 줄에 개똥벌레가 파괴해야 하는 장애물의 최솟값과 그러한 구간의 수를 공백으로 구분하여 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/\352\260\234\353\230\245\353\262\214\353\240\210.java" "b/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/\352\260\234\353\230\245\353\262\214\353\240\210.java" new file mode 100644 index 00000000..647fd654 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/3020.\342\200\205\352\260\234\353\230\245\353\262\214\353\240\210/\352\260\234\353\230\245\353\262\214\353\240\210.java" @@ -0,0 +1,45 @@ +import java.io.*; +import java.util.*; + +public class Main { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + int N = Integer.parseInt(st.nextToken()); + int H = Integer.parseInt(st.nextToken()); + + int[] arr = new int[N]; + int[] up = new int[H + 1]; + int[] down = new int[H + 1]; + + for (int i = 0; i < N; i++) { + arr[i] = Integer.parseInt(br.readLine()); + if (i % 2 == 0) { + down[arr[i]]++; + } else { + up[arr[i]]++; + } + } + + for (int i = H - 1; i >= 1; i--) { + down[i] += down[i + 1]; + up[i] += up[i + 1]; + } + + int[] prefix = new int[H + 1]; + for (int i = 1; i <= H; i++) { + prefix[i] = down[i] + up[H - i + 1]; + } + + int result = Integer.MAX_VALUE; + int count = 0; + for (int i = 1; i <= H; i++) { + result = Math.min(result, prefix[i]); + } + for (int i = 1; i <= H; i++) { + if (prefix[i] == result) + count++; + } + System.out.println(result + " " + count); + } +} diff --git "a/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/README.md" "b/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/README.md" new file mode 100644 index 00000000..3f1b67cc --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/README.md" @@ -0,0 +1,47 @@ +# [Gold IV] 뱀 - 3190 + +[문제 링크](https://www.acmicpc.net/problem/3190) + +### 성능 요약 + +메모리: 12008 KB, 시간: 76 ms + +### 분류 + +자료 구조, 덱, 구현, 큐, 시뮬레이션 + +### 제출 일자 + +2025년 4월 30일 17:59:32 + +### 문제 설명 + +

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다.

+ +

게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.

+ +

뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.

+ +
    +
  • 먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
    • +
  • 만약 벽이나 자기자신의 몸과 부딪히면 게임이 끝난다.
    • +
  • 만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
    • +
  • 만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.
    • +
+ +

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

+ +### 입력 + +

첫째 줄에 보드의 크기 N이 주어진다. (2 ≤ N ≤ 100) 다음 줄에 사과의 개수 K가 주어진다. (0 ≤ K ≤ 100)

+ +

다음 K개의 줄에는 사과의 위치가 주어지는데, 첫 번째 정수는 행, 두 번째 정수는 열 위치를 의미한다. 사과의 위치는 모두 다르며, 맨 위 맨 좌측 (1행 1열) 에는 사과가 없다.

+ +

다음 줄에는 뱀의 방향 변환 횟수 L 이 주어진다. (1 ≤ L ≤ 100)

+ +

다음 L개의 줄에는 뱀의 방향 변환 정보가 주어지는데, 정수 X와 문자 C로 이루어져 있으며. 게임 시작 시간으로부터 X초가 끝난 뒤에 왼쪽(C가 'L') 또는 오른쪽(C가 'D')로 90도 방향을 회전시킨다는 뜻이다. X는 10,000 이하의 양의 정수이며, 방향 전환 정보는 X가 증가하는 순으로 주어진다.

+ +### 출력 + +

첫째 줄에 게임이 몇 초에 끝나는지 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/\353\261\200.java" "b/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/\353\261\200.java" new file mode 100644 index 00000000..15048b80 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/3190.\342\200\205\353\261\200/\353\261\200.java" @@ -0,0 +1,84 @@ +import java.util.*; +import java.io.*; + +public class Main { + static class Pair { + int x; + int y; + Pair(int x, int y) { + this.x = x; + this.y = y; + } + } + + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int N = Integer.parseInt(br.readLine()); + int[][] map = new int[N][N]; + + int K = Integer.parseInt(br.readLine()); + for (int i = 0; i < K; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int r = Integer.parseInt(st.nextToken()); + int c = Integer.parseInt(st.nextToken()); + map[r - 1][c - 1] = 1; // 사과 위치 보정 + } + + Deque timeq = new ArrayDeque<>(); + Deque dirq = new ArrayDeque<>(); + + int L = Integer.parseInt(br.readLine()); + for (int i = 0; i < L; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int t = Integer.parseInt(st.nextToken()); + char d = st.nextToken().charAt(0); + timeq.offer(t); + dirq.offer(d); + } + + int currentDir = 1; // 0: up, 1: right, 2: down, 3: left + int[][] dir = { {-1, 0}, {0, 1}, {1, 0}, {0, -1} }; + + int turn = 0; + Deque snake = new ArrayDeque<>(); + snake.offer(new Pair(0, 0)); + map[0][0] = 2; + + while (true) { + Pair head = snake.peekLast(); + int nx = head.x + dir[currentDir][0]; + int ny = head.y + dir[currentDir][1]; + + // 충돌 검사 + if (nx < 0 || ny < 0 || nx >= N || ny >= N || map[nx][ny] == 2) { + turn++; + break; + } + + if (map[nx][ny] == 1) { // 사과 + map[nx][ny] = 2; + snake.offer(new Pair(nx, ny)); + } else { // 그냥 이동 + map[nx][ny] = 2; + snake.offer(new Pair(nx, ny)); + Pair tail = snake.poll(); + map[tail.x][tail.y] = 0; + } + + turn++; + + // 회전 시점 확인 (이동한 후 회전) + if (!timeq.isEmpty() && turn == timeq.peek()) { + timeq.poll(); + char dirTurn = dirq.poll(); + if (dirTurn == 'D') { + currentDir = (currentDir + 1) % 4; + } else { + currentDir = (currentDir + 3) % 4; + } + } + } + + System.out.println(turn); + } +} diff --git "a/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/README.md" "b/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/README.md" new file mode 100644 index 00000000..aaeccf0e --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/README.md" @@ -0,0 +1,53 @@ +# [Gold III] 불! - 4179 + +[문제 링크](https://www.acmicpc.net/problem/4179) + +### 성능 요약 + +메모리: 51348 KB, 시간: 448 ms + +### 분류 + +너비 우선 탐색, 그래프 이론, 그래프 탐색 + +### 제출 일자 + +2025년 4월 30일 10:56:23 + +### 문제 설명 + +

지훈이는 미로에서 일을 한다. 지훈이를 미로에서 탈출하도록 도와주자!

+ +

미로에서의 지훈이의 위치와 불이 붙은 위치를 감안해서 지훈이가 불에 타기전에 탈출할 수 있는지의 여부, 그리고 얼마나 빨리 탈출할 수 있는지를 결정해야한다.

+ +

지훈이와 불은 매 분마다 한칸씩 수평또는 수직으로(비스듬하게 이동하지 않는다) 이동한다.

+ +

불은 각 지점에서 네 방향으로 확산된다.

+ +

지훈이는 미로의 가장자리에 접한 공간에서 탈출할 수 있다.

+ +

지훈이와 불은 벽이 있는 공간은 통과하지 못한다.

+ +### 입력 + +

입력의 첫째 줄에는 공백으로 구분된 두 정수 R과 C가 주어진다. 단, 1 ≤ R, C ≤ 1000 이다. R은 미로 행의 개수, C는 열의 개수이다.

+ +

다음 입력으로 R줄동안 각각의 미로 행이 주어진다.

+ +

각각의 문자들은 다음을 뜻한다.

+ +
    +
  • #: 벽
    • +
  • .: 지나갈 수 있는 공간
    • +
  • J: 지훈이의 미로에서의 초기위치 (지나갈 수 있는 공간)
    • +
  • F: 불이 난 공간
    • +
+ +

J는 입력에서 하나만 주어진다.

+ +### 출력 + +

지훈이가 불이 도달하기 전에 미로를 탈출 할 수 없는 경우 IMPOSSIBLE 을 출력한다.

+ +

지훈이가 미로를 탈출할 수 있는 경우에는 가장 빠른 탈출시간을 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/\353\266\210\357\274\201.java" "b/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/\353\266\210\357\274\201.java" new file mode 100644 index 00000000..fb02ce51 --- /dev/null +++ "b/\353\260\261\354\244\200/Gold/4179.\342\200\205\353\266\210\357\274\201/\353\266\210\357\274\201.java" @@ -0,0 +1,100 @@ +import java.util.*; +import java.io.*; + +public class Main { + + static class Pair { + int x; + int y; + int turn; + Pair(int x, int y, int turn) { + this.x = x; + this.y = y; + this.turn = turn; + } + } + + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + int n = Integer.parseInt(st.nextToken()); + int m = Integer.parseInt(st.nextToken()); + + char[][] map = new char[n][m]; + int[][] fMap = new int[n][m]; + for(int i = 0; i < n; i++) { + for(int j = 0; j < m; j++) { + fMap[i][j] = Integer.MAX_VALUE; + } + } + + Deque q = new ArrayDeque<>(); + Deque fq = new ArrayDeque<>(); + for(int i = 0; i < n; i++) { + String input = br.readLine(); + for(int j = 0; j < m; j++) { + char curr = input.charAt(j); + map[i][j] = curr; + if (curr == 'J') { + q.offer(new Pair(i, j, 0)); + } else if (curr == 'F') { + fq.offer(new Pair(i, j, 0)); + } + } + } + + int dx[] = {-1, 1, 0, 0}; + int dy[] = {0, 0, -1, 1}; + boolean[][] isVisited = new boolean[n][m]; + boolean[][] isFireVisited = new boolean[n][m]; + + int result = 0; + while(!fq.isEmpty()) { + Pair f = fq.poll(); + for(int i = 0; i < 4; i++) { + int nFx = f.x + dx[i]; + int nFy = f.y + dy[i]; + int nFt = f.turn + 1; + + if (nFx < 0 || nFy < 0 || nFx >= n || nFy >= m || map[nFx][nFy] == '#' || isFireVisited[nFx][nFy] || nFt >= fMap[nFx][nFy]) { + continue; + } + fMap[nFx][nFy] = nFt; + fq.offer(new Pair(nFx, nFy, nFt)); + isFireVisited[nFx][nFy] = true; + } + } + + boolean flag = false; + while (!q.isEmpty()) { + Pair p = q.poll(); + + for(int i = 0; i < 4; i++) { + int nx = p.x + dx[i]; + int ny = p.y + dy[i]; + int nt = p.turn + 1; + if (nx < 0 || ny < 0 || nx >= n || ny >= m) { + flag = true; +// System.out.println("nx: " + nx + " ny: " + ny); + result = nt; + break; + } + + if (nt >= fMap[nx][ny] || map[nx][ny] != '.' || isVisited[nx][ny]) { +// System.out.println("nx: " + nx + " ny: " + ny + " nt: " + nt + " fmap: " + fMap[nx][ny]); + continue; + } + q.offer(new Pair(nx, ny, nt)); + isVisited[nx][ny] = true; + } + if (flag) + break; + } + + if (flag) { + System.out.println(result); + } else { + System.out.println("IMPOSSIBLE"); + } + } +} \ No newline at end of file diff --git "a/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/README.md" "b/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/README.md" new file mode 100644 index 00000000..4c11fbb5 --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/README.md" @@ -0,0 +1,32 @@ +# [Silver I] 쉬운 최단거리 - 14940 + +[문제 링크](https://www.acmicpc.net/problem/14940) + +### 성능 요약 + +메모리: 83436 KB, 시간: 1724 ms + +### 분류 + +그래프 이론, 그래프 탐색, 너비 우선 탐색, 격자 그래프 + +### 제출 일자 + +2025년 5월 5일 19:30:30 + +### 문제 설명 + +

지도가 주어지면 모든 지점에 대해서 목표지점까지의 거리를 구하여라.

+ +

문제를 쉽게 만들기 위해 오직 가로와 세로로만 움직일 수 있다고 하자.

+ +### 입력 + +

지도의 크기 n과 m이 주어진다. n은 세로의 크기, m은 가로의 크기다.(2 ≤ n ≤ 1000, 2 ≤ m ≤ 1000)

+ +

다음 n개의 줄에 m개의 숫자가 주어진다. 0은 갈 수 없는 땅이고 1은 갈 수 있는 땅, 2는 목표지점이다. 입력에서 2는 단 한개이다.

+ +### 출력 + +

각 지점에서 목표지점까지의 거리를 출력한다. 원래 갈 수 없는 땅인 위치는 0을 출력하고, 원래 갈 수 있는 땅인 부분 중에서 도달할 수 없는 위치는 -1을 출력한다.

+ diff --git "a/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254.java" "b/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254.java" new file mode 100644 index 00000000..b3ba5ba1 --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/14940.\342\200\205\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254/\354\211\254\354\232\264\342\200\205\354\265\234\353\213\250\352\261\260\353\246\254.java" @@ -0,0 +1,75 @@ +import java.io.*; +import java.util.*; + +public class Main { + + static class Pair { + int x; + int y; + int distance; + Pair(int x, int y, int distance) { + this.x = x; + this.y = y; + this.distance = distance; + } + } + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + int n = Integer.parseInt(st.nextToken()); + int m = Integer.parseInt(st.nextToken()); + + int[][] map = new int[n][m]; + boolean[][] isVisited = new boolean[n][m]; + + Pair start = new Pair(0, 0, 0); + for(int i = 0; i < n; i++) { + st = new StringTokenizer(br.readLine()); + for(int j = 0; j < m; j++) { + int input = Integer.parseInt(st.nextToken()); + if (input == 1) + input *= -1; + map[i][j] = input; + if (map[i][j] == 2) { + start.x = i; + start.y = j; + start.distance = 0; + } + } + } + + map[start.x][start.y] = 0; + Deque q = new ArrayDeque<>(); + q.offer(start); + isVisited[start.x][start.y] = false; + int[] dx = {-1, 1, 0, 0}; + int[] dy = {0, 0, -1, 1}; + while(!q.isEmpty()) { + Pair p = q.poll(); + + for(int i = 0; i < 4; i++) { + int nx = p.x + dx[i]; + int ny = p.y + dy[i]; + + + if (nx < 0 || ny < 0 || nx >= n || ny >= m || isVisited[nx][ny]) { + continue; + } + if (map[nx][ny] == 0) { + isVisited[nx][ny] = true; + continue; + } + q.offer(new Pair(nx, ny, p.distance + 1)); + map[nx][ny] = p.distance + 1; + isVisited[nx][ny] = true; + } + } + + for(int i = 0; i < n; i++) { + for(int j = 0; j < m; j++) { + System.out.print(map[i][j] + " "); + } + System.out.println(); + } + } +} \ No newline at end of file diff --git "a/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/README.md" "b/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/README.md" new file mode 100644 index 00000000..e2b72b85 --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/README.md" @@ -0,0 +1,38 @@ +# [Silver I] 어두운 건 무서워 - 16507 + +[문제 링크](https://www.acmicpc.net/problem/16507) + +### 성능 요약 + +메모리: 82500 KB, 시간: 592 ms + +### 분류 + +누적 합 + +### 제출 일자 + +2025년 5월 7일 21:56:50 + +### 문제 설명 + +

호근이는 겁이 많아 어두운 것을 싫어한다. 호근이에게 어떤 사진을 보여주려는데 사진의 밝기가 평균 이상이 되지 않으면 일절 보려 하지 않는다. 호근이가 이 사진에서 일부분이라도 볼 수 있는 부분을 찾아주자.

+ +

+ +

위 그림은 호근이에게 보여줄 5×6 크기의 사진이며, 각 픽셀은 밝기를 나타낸다. 호근이가 사진의 일부분이라도 볼 수 있는지 알아보기 위해서는 두 점 (r1, c1)과 (r2, c2)를 꼭짓점으로 하는 직사각형의 밝기 평균을 구해야 한다. 예를 들어, 위 그림에서는 (2, 2)와 (4, 5)를 꼭짓점으로 하는 직사각형을 말한다.

+ +

호근이에게 보여줄 R×C 크기의 사진이 주어질 때, 사진의 일부분에 해당하는 밝기 평균을 구하여라.

+ +### 입력 + +

첫 번째 줄에는 사진의 크기를 의미하는 정수 R, C (1 ≤ R, C ≤ 1,000)와 사진 일부분의 밝기 평균을 알아볼 개수를 의미하는 정수 Q (1 ≤ Q ≤ 10,000)가 주어진다.

+ +

다음 R개의 줄에 걸쳐 R×C 크기의 사진 정보가 주어지며, 사진의 각 픽셀에는 밝기를 의미하는 정수 K (1 ≤ K ≤ 1,000)가 주어진다.

+ +

다음 Q개의 각 줄에는 사진의 일부분을 나타내기 위한 두 꼭짓점을 의미하는 정수 r1, c1, r2, c2 (1 ≤ r1 ≤ r2 ≤ R, 1 ≤ c1 ≤ c2 ≤ C)가 주어진다.

+ +### 출력 + +

Q개의 각 줄에 주어진 사진에서 두 점 (r1, c1)과 (r2, c2)를 꼭짓점으로 하는 직사각형의 밝기 평균을 출력한다. 평균은 정수 나눗셈으로 몫만 취한다.

+ diff --git "a/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214.java" "b/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214.java" new file mode 100644 index 00000000..8d0edeee --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/16507.\342\200\205\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214/\354\226\264\353\221\220\354\232\264\342\200\205\352\261\264\342\200\205\353\254\264\354\204\234\354\233\214.java" @@ -0,0 +1,38 @@ +import java.util.*; +import java.io.*; + +public class Main { + public static void main(String args[]) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); + + StringTokenizer st = new StringTokenizer(br.readLine()); + int R = Integer.parseInt(st.nextToken()); + int C = Integer.parseInt(st.nextToken()); + int Q = Integer.parseInt(st.nextToken()); + + int[][] arr = new int[R + 1][C + 1]; + int[][] prefix = new int[R + 1][C + 1]; + for (int i = 1; i <= R; i++) { + st = new StringTokenizer(br.readLine()); + for (int j = 1; j <= C; j++) { + arr[i][j] = Integer.parseInt(st.nextToken()); + prefix[i][j] = prefix[i][j - 1] + arr[i][j]; + } + } + + for (int i = 0; i < Q; i++) { + st = new StringTokenizer(br.readLine()); + int r1 = Integer.parseInt(st.nextToken()); + int c1 = Integer.parseInt(st.nextToken()); + int r2 = Integer.parseInt(st.nextToken()); + int c2 = Integer.parseInt(st.nextToken()); + int sum = 0; + for (int r = r1; r <= r2; r++) { + sum += prefix[r][c2] - prefix[r][c1 - 1]; + } + bw.write((sum / ((r2 - r1 + 1) * (c2 - c1 + 1))) + "\n"); + } + bw.close(); + } +} \ No newline at end of file diff --git "a/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230.java" "b/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230.java" new file mode 100644 index 00000000..13f41f09 --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230.java" @@ -0,0 +1,50 @@ +import java.io.*; +import java.util.*; + +public class Main { + static int N, M; + static ArrayList arr; + static ArrayList title; + + 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()); + + arr = new ArrayList<>(); + title = new ArrayList<>(); + + for (int i = 0; i < N; i++) { + st = new StringTokenizer(br.readLine()); + String t = st.nextToken(); + int value = Integer.parseInt(st.nextToken()); + if (arr.isEmpty() || arr.get(arr.size() - 1) != value) { + arr.add(value); + title.add(t); + } + } + + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < M; i++) { + int input = Integer.parseInt(br.readLine()); + sb.append(title.get(solve(input))).append("\n"); + } + System.out.print(sb); + } + + static int solve(int n) { + int left = 0; + int right = arr.size() - 1; + + while (left <= right) { + int mid = (left + right) / 2; + if (arr.get(mid) < n) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return left; + } +} diff --git "a/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/README.md" "b/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/README.md" new file mode 100644 index 00000000..a91d1533 --- /dev/null +++ "b/\353\260\261\354\244\200/Silver/19637.\342\200\205IF\353\254\270\342\200\205\354\242\200\342\200\205\353\214\200\354\213\240\342\200\205\354\215\250\354\244\230/README.md" @@ -0,0 +1,43 @@ +# [Silver III] IF문 좀 대신 써줘 - 19637 + +[문제 링크](https://www.acmicpc.net/problem/19637) + +### 성능 요약 + +메모리: 60672 KB, 시간: 372 ms + +### 분류 + +이분 탐색 + +### 제출 일자 + +2025년 4월 29일 21:33:42 + +### 문제 설명 + +

게임 개발자인 밀리는 전투력 시스템을 만들어, 캐릭터가 가진 전투력을 기준으로 칭호를 붙여주려고 한다.

+ +

예를 들어, 전투력 10,000 이하의 캐릭터는 WEAK, 10,000 초과 그리고 100,000 이하의 캐릭터는 NORMAL, 100,000 초과 그리고 1,000,000 이하의 캐릭터는 STRONG 칭호를 붙여준다고 하자. 이를 IF문으로 작성한다면 아래와 같이 구현할 수 있다.

+ +
if power <= 10000
+ print WEAK
+else if power <= 100000
+ print NORMAL
+else if power <= 1000000
+ print STRONG
+ +

혼자서 게임을 개발하느라 매우 바쁜 밀리를 대신해서, 캐릭터의 전투력에 맞는 칭호를 출력하는 프로그램을 작성하자.

+ +### 입력 + +

첫 번째 줄에는 칭호의 개수 N (1 ≤ N ≤ 105)과 칭호를 출력해야 하는 캐릭터들의 개수 M (1 ≤ M ≤ 105)이 빈칸을 사이에 두고 주어진다. (1 ≤ N, M ≤ 105)

+ +

두 번째 줄부터 N개의 줄에 각 칭호의 이름을 나타내는 길이 1 이상, 11 이하의 영어 대문자로만 구성된 문자열과 해당 칭호의 전투력 상한값을 나타내는 109 이하의 음이 아닌 정수가 주어진다. 칭호는 전투력 상한값의 비내림차순으로 주어진다.

+ +

N + 2번째 줄부터 M개의 각 줄에는 캐릭터의 전투력을 나타내는 음이 아닌 정수가 주어진다. 해당하는 칭호가 없는 전투력은 입력으로 주어지지 않는다.

+ +### 출력 + +

M개의 줄에 걸쳐 캐릭터의 전투력에 맞는 칭호를 입력 순서대로 출력한다. 어떤 캐릭터의 전투력으로 출력할 수 있는 칭호가 여러 개인 경우 가장 먼저 입력된 칭호 하나만 출력한다.

+