solve: week07 SungHee

src/week07/sunghee/p1/Main.java

@@ -0,0 +1,109 @@
+package week07.sunghee.p1;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+/**
+ * 문제 링크 :https://www.acmicpc.net/problem/16926
+ * 메모리 : 32220 KB
+ * 시간 : 672ms
+ */
+
+/**
+ * 두 변 중 작은 변 / 2 : 회전하는 태두리 수
+ * ex) 4X5 한다면 2개의 태두리 가 나온다고 생각
+ * 가장 바깥 테두리:(0,0), (0,1), (0,2), (0,3), (0,4), (1,4),(2,4),(3,4),(3,3),...
+ * 가장 안쪽 테두리:(1,1), (1,2), (1,3), (2,3), (2,2), (2,1)
+ * 
+ * 좌표 이동
+ * 테두리 마다 회전하는 규칙 (왼, 위, 오, 아래) 순으로 이동
+ *      죄표 움직임을 dy, dx로 지정,
+ *      idx 는 범위가 벗어 날 경우 +1함
+ * idx가 4보다 작을 동안 좌표를 움직여 주면 한 테두리의 좌표가 이동됨
+ * 
+ * 회전 수 만큼, 회전하는 태두리 수 만큼 좌표 이동을 반복해줌
+ */
+
+public class Main {
+
+    public static void main(String[] args) throws Exception{
+        new Main().sol_16926();
+    }
+
+    int[][] map;
+
+    void sol_16926() 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 R = Integer.parseInt(st.nextToken());
+
+
+        map = new int[N][M];
+
+        for(int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            for(int j = 0; j < M; j++) {
+                map[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+
+        for(int i = 0; i < R; i++) {
+            rotate();
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for(int[] arr : map) {
+            for(int a: arr){
+                sb.append(a).append(" ");
+            }
+
+            sb.append("\n");
+        }
+
+
+        System.out.println(sb);
+
+    }
+
+
+    void rotate() {
+
+        int[] dx = new int[] {1, 0, -1, 0};
+        int[] dy = new int[] {0, 1, 0, -1};
+
+        int n = map.length;
+        int m = map[0].length;
+
+        //작은 수가 짝수
+        int min = Math.min(n, m);
+
+        for(int i = 0; i < min/2; i++) {
+            int x = i;
+            int y = i;
+
+            int tmp = map[y][x];
+
+            int idx = 0;
+            while(idx < 4) {
+                int nx = x + dx[idx];
+                int ny = y + dy[idx];
+
+                if(ny >= n-i || ny < i || nx >= m -i || nx < i) {
+                    idx++;
+                    continue;
+                }
+
+                map[y][x] = map[ny][nx];
+                y = ny;
+                x = nx;
+            }
+            map[i + 1][i] = tmp;
+        }
+    }
+}

src/week07/sunghee/p2/Main.java

@@ -0,0 +1,74 @@
+package week07.sunghee.p2;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * 문제 링크 :https://www.acmicpc.net/problem/14719
+ * 메모리 : 11644 KB
+ * 시간 : 72 ms
+ */
+
+/**
+ * 왼쪽 기둥과, 오른쪽 기둥의 최대 높이에 따리 빗물이 고임
+ * 따라서 왼쪽에서 오늘쪽으로 가면서 기둥의 최대 값을 저장(LM)
+ * 오른쪽에서 왼쪽으로 가면서 기둥의  최대 값을 저장(RM)
+ * LM과 RM 중 작은 값이 빗물의 높이라고 생각하고
+ * 빗물이 고인 량을 구하기 위해 빗물의 높이 - 블로의 크기를 구함
+ * 
+ * ex)
+ * block  : 3 1 2 3 4 1 1 2
+ * 
+ * LM     : 3 3 3 3 4 4 4 4
+ * RM     : 4 4 4 4 4 2 2 2
+ * 빗물H  : 3 3 3 3 4 2 2 2
+ * 
+ * 빗물량 : 0 2 1 0 0 1 1 0
+ */
+
+public class Main {
+
+    public static void main(String[] args) throws Exception{
+        new Main().sol_14719();
+    }
+
+
+    public void sol_14719() throws Exception {
+        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());
+
+        int[] blocks = new int[W];
+        int[] leftToRightMax = new int[W];
+        int[] rain = new int[W];
+
+        int max = 0;
+
+        st = new StringTokenizer(br.readLine());
+        for(int i = 0; i < W; i++) {
+            //1. block 값 저장
+            int b = Integer.parseInt(st.nextToken());
+            blocks[i] = b;
+
+            //2. left -> right로 가면서 가장 큰값 저장
+            max = Math.max(max, b);
+            leftToRightMax[i] = max;
+        }
+
+        max = 0;
+        int rianCnt = 0;
+
+        for(int i = W-1; i >= 0; i--) {
+            //3. right -> left로 가면서 가장 큰값 저장
+            max = Math.max(max, blocks[i]);
+
+            // 4. right -> left의 큰값과 left -> right 큰값 중 비교해서 작은 값이 빗물의 높이
+            rain[i] = Math.min(max, leftToRightMax[i]);
+            //5. 블록 높이 - 빗물 높이가 고이는 빗물의 량
+            rianCnt += rain[i] -  blocks[i];
+        }
+
+        System.out.println(rianCnt);
+    }
+}

src/week07/sunghee/p3/Main.java

@@ -0,0 +1,86 @@
+package week07.sunghee.p3;
+
+import java.io.*;
+import java.util.*;
+
+ /**
+ * 문제 링크 :https://www.acmicpc.net/problem/21939
+ * 메모리 : 57196 KB
+ * 시간 : 556 ms
+ */
+
+/**
+ * problems : TreeSet으로 문제를 난이도 순, 문제 번호 순으로 정렬 함
+ * map : HashMap으로 문제 번호와 난이도를 관리
+ * 
+ * problems의 문제를 지울 때, map에서 난이도를 값을 찾아서 이용
+ */
+
+public class Main {
+
+    public static void main(String[] args) throws Exception{
+        new Main().sol_21939();
+    }
+
+    class Problem{
+        int p, l;
+
+        public Problem(int p, int l) {
+            this.p = p;
+            this.l = l;
+        }
+    }
+
+    public void sol_21939() throws Exception {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+
+        TreeSet<Problem> problems = new TreeSet<>((o1, o2) -> {
+            if (o1.l == o2.l) { // 문제 난이도가 같다면
+				return o1.p - o2.p; // 문제 번호가 작은 것 순서대로
+			}
+			return o1.l - o2.l;
+        });
+
+
+        // 문제 번호와 난이도를 관리하기 위한 map
+        Map<Integer, Integer> map = new HashMap<>();
+
+
+        for(int i =0; i < N; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int P = Integer.parseInt(st.nextToken());
+            int L = Integer.parseInt(st.nextToken());
+            problems.add(new Problem(P, L));
+            map.put(P, L);
+        }
+
+
+        int M = Integer.parseInt(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        for(int i =0; i < M; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            switch(st.nextToken()) {
+                case "recommend":
+                    int x = Integer.parseInt(st.nextToken());
+                    Problem problem = (x == 1 ? problems.last() : problems.first());
+                    sb.append(problem.p).append("\n");
+                    break;
+                case "add":
+                    int p = Integer.parseInt(st.nextToken());
+                    int l = Integer.parseInt(st.nextToken());
+                    problems.add(new Problem(p, l));
+                    map.put(p, l);
+                    break;
+                default:
+                    //solve
+                    int s = Integer.parseInt(st.nextToken());
+                    //treeset은 모든 객체 비교를 comparTo()로 비교하기 때문에 equals를 오버라이딩 안해도 동일한 객체로 간주
+                    problems.remove(new Problem(s, map.get(s)));
+                    break;
+            }
+        }
+        System.out.println(sb);
+    }
+}