Developer YEOM2

[백준 : 골드3] Java BJ1600 말이 되고픈 원숭이

굼벵욤 — Wed, 29 May 2024 09:00:06 +0900

#️⃣문제

근데 원숭이는 한 가지 착각하고 있는 것이 있다. 말은 저렇게 움직일 수 있지만 원숭이는 능력이 부족해서 총 K번만 위와 같이 움직일 수 있고, 그 외에는 그냥 인접한 칸으로만 움직일 수 있다. 대각선 방향은 인접한 칸에 포함되지 않는다.

이제 원숭이는 머나먼 여행길을 떠난다. 격자판의 맨 왼쪽 위에서 시작해서 맨 오른쪽 아래까지 가야한다. 인접한 네 방향으로 한 번 움직이는 것, 말의 움직임으로 한 번 움직이는 것, 모두 한 번의 동작으로 친다. 격자판이 주어졌을 때, 원숭이가 최소한의 동작으로 시작지점에서 도착지점까지 갈 수 있는 방법을 알아내는 프로그램을 작성하시오.

#️⃣ 입력

첫째 줄에 정수 K가 주어진다. 둘째 줄에 격자판의 가로길이 W, 세로길이 H가 주어진다. 그 다음 H줄에 걸쳐 W개의 숫자가 주어지는데, 0은 아무것도 없는 평지, 1은 장애물을 뜻한다. 장애물이 있는 곳으로는 이동할 수 없다. 시작점과 도착점은 항상 평지이다. W와 H는 1이상 200이하의 자연수이고, K는 0이상 30이하의 정수이다.

#️⃣ 출력

첫째 줄에 원숭이의 동작수의 최솟값을 출력한다. 시작점에서 도착점까지 갈 수 없는 경우엔 -1을 출력한다.

✅ 풀이 Point

1️⃣ D[H][W][K+1] 배열 선언

2차원 배열로 arr의 위치를 나타내고 [K + 1]로 해당 위치까지 오면서 말처럼 몇 번 이동해서 왔는지를 표시하기 위함.
ex) D[2][3][1] : (2, 3)의 위치에 말처럼 1번 이동해서 도착 가능
최소한의 동작으로 마지막 위치까지 도달해야하기 때문에 Arrays.fill(D[i][j], Integer.MAX_VALUE)로 초기화

int[][][] D = new int[H][W][K + 1];
for (int i = 0; i < H; i++) {
    for (int j = 0; j < W; j++) Arrays.fill(D[i][j], Integer.MAX_VALUE);
}

2️⃣ Node class 선언

현재 넣어진 q에 넣어진 Node의 위치 뿐만 아니라 말처럼 몇 번 이동해서 온 경우인지도 판단해야 3차원 배열 D를 채워줄 수 있음.
→ Node 속성으로 가로, 세로, 말처럼 이동한 횟수가 필요함.

public static class Node {
    int i;
    int j;
    int cnt;

    public Node(int i, int j, int cnt) {
        this.i = i;
        this.j = j;
        this.cnt = cnt;
    }
}

3️⃣ bfs() 함수 선언

q에서 node를 하나 뽑았을 때 위치가 도착 지점일 경우 while문 탈출
while 문을 탈출하지 못한 채로 while문이 종료된 경우, 출발 지점에서 도착 지점까지 어떠한 경우의 수로도 도달할 수 없다는 것을 의미함.
→ -1 반환
node.cnt 속성 확인 후 말처럼 이동할 수 있는지 없는지 boolean flag 변수를 통해 판단
→ 말처럼 이동하는 걸 먼저 하고 있기 때문에 도착지점에 처음 도달했을 때가 최소한의 동작 횟수로 도착 지점까지 도달한 경우임.

private static int bfs(int si, int sj) {
    Queue<Node> q = new LinkedList<>();
    int[][][] D = new int[H][W][K + 1];
    for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) Arrays.fill(D[i][j], Integer.MAX_VALUE);
    }

    q.offer(new Node(si, sj, 0));
    D[si][sj][0] = 1;
    while (!q.isEmpty()) {
        Node node = q.poll();

        if (node.i == H - 1 && node.j == W - 1) return D[node.i][node.j][node.cnt] - 1;

        boolean flag = true;
        if (node.cnt == K) flag = false; // 말처럼 이동할 수 있는 범위를 이미 다 이동했다면 나이트로의 이동은 불가능

        if (flag) { // 말처럼 이동 가능
            for (int k = 0; k < 8; k++) {
                int ni = node.i + di8[k];
                int nj = node.j + dj8[k];
                if (0 <= ni && ni < H && 0 <= nj && nj < W && arr[ni][nj] && D[ni][nj][node.cnt + 1] == Integer.MAX_VALUE) {
                    D[ni][nj][node.cnt + 1] = D[node.i][node.j][node.cnt] + 1;
                    q.offer(new Node(ni, nj, node.cnt + 1));
                }
            }
        }

        for (int k = 0; k < 4; k++) {
            int ni = node.i + di4[k];
            int nj = node.j + dj4[k];
            if (0 <= ni && ni < H && 0 <= nj && nj < W && arr[ni][nj] && D[ni][nj][node.cnt] == Integer.MAX_VALUE) {
                D[ni][nj][node.cnt] = D[node.i][node.j][node.cnt] + 1;
                q.offer(new Node(ni, nj, node.cnt));
            }
        }
    }
    return -1;
}

✅ 정답

import java.io.*;
import java.util.*;

public class Main {
    static int K, W, H;
    static boolean[][] arr; // true : 평지, false : 장애물

    static int[] di8 = {-2, -1, 1, 2, 2, 1, -1, -2};
    static int[] dj8 = {1, 2, 2, 1, -1, -2, -2, -1};

    static int[] di4 = {-1, 0, 1, 0};
    static int[] dj4 = {0, 1, 0, -1};


    public static class Node {
        int i;
        int j;
        int cnt;

        public Node(int i, int j, int cnt) {
            this.i = i;
            this.j = j;
            this.cnt = cnt;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        K = Integer.parseInt(br.readLine());

        StringTokenizer st = new StringTokenizer(br.readLine());
        W = Integer.parseInt(st.nextToken());
        H = Integer.parseInt(st.nextToken());

        arr = new boolean[H][W];
        for (int i = 0; i < H; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < W; j++) {
                if (Integer.parseInt(st.nextToken()) == 0) arr[i][j] = true;
            }
        }
        System.out.println(bfs(0, 0));
    }

    private static int bfs(int si, int sj) {
        Queue<Node> q = new LinkedList<>();
        int[][][] D = new int[H][W][K + 1];
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) Arrays.fill(D[i][j], Integer.MAX_VALUE);
        }

        q.offer(new Node(si, sj, 0));
        D[si][sj][0] = 1;
        while (!q.isEmpty()) {
            Node node = q.poll();

            if (node.i == H - 1 && node.j == W - 1) return D[node.i][node.j][node.cnt] - 1;

            boolean flag = true;
            if (node.cnt == K) flag = false; // 말처럼 이동할 수 있는 범위를 이미 다 이동했다면 나이트로의 이동은 불가능

            if (flag) { // 말처럼 이동 가능
                for (int k = 0; k < 8; k++) {
                    int ni = node.i + di8[k];
                    int nj = node.j + dj8[k];
                    if (0 <= ni && ni < H && 0 <= nj && nj < W && arr[ni][nj] && D[ni][nj][node.cnt + 1] == Integer.MAX_VALUE) {
                        D[ni][nj][node.cnt + 1] = D[node.i][node.j][node.cnt] + 1;
                        q.offer(new Node(ni, nj, node.cnt + 1));
                    }
                }
            }

            for (int k = 0; k < 4; k++) {
                int ni = node.i + di4[k];
                int nj = node.j + dj4[k];
                if (0 <= ni && ni < H && 0 <= nj && nj < W && arr[ni][nj] && D[ni][nj][node.cnt] == Integer.MAX_VALUE) {
                    D[ni][nj][node.cnt] = D[node.i][node.j][node.cnt] + 1;
                    q.offer(new Node(ni, nj, node.cnt));
                }
            }
        }
        return -1;
    }
}

[백준 : 골드3] Java BJ2457 공주님의 정원

굼벵욤 — Tue, 7 May 2024 09:00:36 +0900

#️⃣문제

오늘은 공주님이 태어난 경사스러운 날이다. 왕은 이날을 기념하기 위해 늘 꽃이 피어있는 작은 정원을 만들기로 결정했다.

총 N개의 꽃이 있는데, 꽃은 모두 같은 해에 피어서 같은 해에 진다. 하나의 꽃은 피는 날과 지는 날이 정해져 있다. 예를 들어, 5월 8일에 피어서 6월 13일 지는 꽃은 5월 8일부터 6월 12일까지는 꽃이 피어 있고, 6월 13일을 포함하여 이후로는 꽃을 볼 수 없다는 의미이다. (올해는 4, 6, 9, 11월은 30일까지 있고, 1, 3, 5, 7, 8, 10, 12월은 31일까지 있으며, 2월은 28일까지만 있다.)

이러한 N개의 꽃들 중에서 다음의 두 조건을 만족하는 꽃들을 선택하고 싶다.

공주가 가장 좋아하는 계절인 3월 1일부터 11월 30일까지 매일 꽃이 한 가지 이상 피어 있도록 한다.
피어 있도록 꽃들을 선택할 때, 선택한 꽃들의 최소 개수를 출력하는 프로그램을 작성하시오.

N개의 꽃들 중에서 위의 두 조건을 만족하는, 즉 3월 1일부터 11월 30일까지 매일 꽃이 한 가지 이상 피어 있도록 꽃들을 선택할 때, 선택한 꽃들의 최소 개수를 출력하는 프로그램을 작성하시오.

#️⃣ 입력

첫째 줄에는 꽃들의 총 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 각 꽃이 피는 날짜와 지는 날짜가 주어진다. 하나의 날짜는 월과 일을 나타내는 두 숫자로 표현된다. 예를 들어서, 3 8 7 31은 꽃이 3월 8일에 피어서 7월 31일에 진다는 것을 나타낸다.

#️⃣ 출력

첫째 줄에 선택한 꽃들의 최소 개수를 출력한다. 만약 두 조건을 만족하는 꽃들을 선택할 수 없다면 0을 출력한다.

✅ 풀이 Point

1️⃣ 피는 날(s), 지는 날(e)를 속성으로 가지는 Flower 클래스 생성

정렬 기준 : 피는 날 오름차순, 지는 날 내림차순 → 빨리 피는 꽃 중 가장 길게 피어있는 꽃 순서대로 정렬

static class Flower implements Comparable<Flower> {
    int s;
    int e;

    public Flower(int s, int e) {
        this.s = s;
        this.e = e;
    }
    // 시작 오름차순, 종료 내림차순
    @Override
    public int compareTo(Flower o) {
        if (this.s == o.s) return o.e - this.e;
        return this.s - o.s;
    }
}

2️⃣ 정렬 후 꽃 선택 알고리즘 설명

✔️ boolean flag : 현재 while문을 탐색하면서 꽃을 새로 선택했는지 안 했는지 판별
✔️ int idx : 현재 선택한 꽃의 인덱스, 초기값은 어떤 꽃도 선택되지 않았고 처음부터 탐색해야하기 때문에 idx = 0
✔️ int s : 현재 선택한 꽃들이 지는 날짜(s 이전의 날짜까지는 꽃이 피어있음.)
✔️ int max : while문 내부의 for문 안에서 s 날짜를 포함하여 이전 날에 피어서 가장 오래 피어있는 꽃의 지는 날짜

s보다 이후에 피면 꽃이 연결되어서 피지 못하기 때문에 반복문 종료
s 날짜를 포함하여 이전 날에 피어서 가장 오래 피어있는 꽃을 while문 내부의 for문을 통해 찾고, 이후 while문에서 선택된 꽃의 다음 인덱스부터 꽃을 탐색하도록 idx = idx + 1; 갱신

while (s < e) {
    boolean flag = false;

    for (int i = idx; i < N; i++) {
        // s보다 이후에 피면 의미 없음. -> 진 후 바로 피어야 함.
        if (flowers[i].s > s) break;

        if (max < flowers[i].e) {
            flag = true;
            max = flowers[i].e;
            idx = i + 1;
        }
    }
}

flag = true, 새로운 꽃이 선택되었으면 s = max 값으로 갱신 및 cnt++;
flag = false, 새로운 꽃이 선택되지 않았으므로, 반복문 종료

while (s < e) {
    ...
    if (flag) {
        s = max;
        cnt++;
    } else {
        break;
    }
}

✅ 정답

import java.io.*;
import java.util.*;

public class Main {
    static class Flower implements Comparable<Flower> {
        int s;
        int e;

        public Flower(int s, int e) {
            this.s = s;
            this.e = e;
        }
        // 시작 오름차순, 종료 내림차순
        @Override
        public int compareTo(Flower o) {
            if (this.s == o.s) return o.e - this.e;
            return this.s - o.s;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine().strip());
        Flower[] flowers = new Flower[N];

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine().strip());
            int sm = Integer.parseInt(st.nextToken());
            int sd = Integer.parseInt(st.nextToken());
            int em = Integer.parseInt(st.nextToken());
            int ed = Integer.parseInt(st.nextToken());
            flowers[i] = new Flower(sm * 100 + sd, em * 100 + ed);
        }
        Arrays.sort(flowers);

        int cnt = 0; int max = 0; int idx = 0;
        int s = 301; int e = 1201;
        while (s < e) {
            boolean flag = false;

            for (int i = idx; i < N; i++) {
                // s보다 이후에 피면 의미 없음. -> 진 후 바로 피어야 함.
                if (flowers[i].s > s) break;

                if (max < flowers[i].e) {
                    flag = true;
                    max = flowers[i].e;
                    idx = i + 1;
                }
            }

            if (flag) {
                s = max;
                cnt++;
            } else {
                break;
            }
        }
        System.out.println(s < e ? 0 : cnt);
    }
}

[프로그래머스 : JOIN] Front End 개발자 찾기

굼벵욤 — Mon, 6 May 2024 09:00:18 +0900

#️⃣ 문제 설명

[SKILLCODES] 테이블은 개발자들이 사용하는 프로그래밍 언어에 대한 정보를 담은 테이블입니다.

[SKILLCODES] 테이블의 구조는 다음과 같으며, NAME, CATEGORY, CODE 는 각각 스킬의 이름, 스킬의 범주, 스킬의 코드를 의미합니다. 스킬의 코드는 2진수로 표현했을 때 각 bit로 구분될 수 있도록 2의 제곱수로 구성되어 있습니다.

NAME	TYPE	UNIQUE	NULLABLE
NAME	VARCHAR(N)	Y	N
CATEGORY	VARCHAR(N)	N	N
CODE	INTEGER	Y	N

[DEVELOPERS] 테이블은 개발자들의 프로그래밍 스킬 정보를 담은 테이블입니다. [DEVELOPERS] 테이블의 구조는 다음과 같으며, ID, FIRST_NAME, LAST_NAME, EMAIL, SKILL_CODE 는 각각 개발자의 ID, 이름, 성, 이메일, 스킬 코드를 의미합니다. SKILL_CODE 컬럼은 INTEGER 타입이고, 2진수로 표현했을 때 각 bit는 [SKILLCODES] 테이블의 코드를 의미합니다.

#️⃣ 문제

[DEVELOPERS] 테이블에서 Front End 스킬을 가진 개발자의 정보를 조회하려 합니다. 조건에 맞는 개발자의 ID, 이메일, 이름, 성을 조회하는 SQL 문을 작성해 주세요.
결과는 ID를 기준으로 오름차순 정렬해 주세요.

#️⃣ 예시

예를 들어 [SKILLCODES] 테이블이 다음과 같고,

NAME	CATEGORY	CODE
C++	Back End	4
JavaScript	Front End	16
Java	Back End	128
Python	Back End	256
C#	Back End	1024
React	Front End	2048
Vue	Front End	8192
Node.js	Back End	16384

[DEVELOPERS] 테이블이 다음과 같다면

ID	FIRST_NAME	LAST_NAME	EMAIL	SKILL_CODE
D165	Jerami	Edwards	jerami_edwards@grepp.co	400
D161	Carsen	Garza	carsen_garza@grepp.co	2048
D164	Kelly	Grant	kelly_grant@grepp.co	1024
D163	Luka	Cory	luka_cory@grepp.co	16384
D162	Cade	Cunningham	cade_cunningham@grepp.co	8452

다음과 같이 [DEVELOPERS] 테이블에 포함된 개발자 중 Front End 스킬을 가진을 가진 개발자의 정보가 결과에 나와야 합니다.

ID	EMAIL	FIRST_NAME	LAST_NAME
D161	carsen_garza@grepp.co	Carsen	Garza
D162	cade_cunningham@grepp.co	Cade	Cunningham
D165	jerami_edwards@grepp.co	Jerami	Edwards

✅ 풀이 Point

1️⃣ CATEGORY가 "Front End"로 되어있는 코드만 추출해서 FRONTEND라는 가상 테이블을 생성

Front End 기술을 2개 이상 가진 개발자가 존재할 수 있기 때문에 DISTINCT를 통해 중복 제거

2️⃣ 서브 쿼리 사용

1️⃣과 같이 Front End 기술을 여러 개 가진 개발자는 여러 번 출력될 수 있기 때문에 DISTINCT를 통해 중복 제거 필요

3️⃣ CODE가 비트 연산을 할 수 있게 구성되어있으므로 CATEGORY가 Front End인 기술을 다 합해서 각 개발자의 기술 코드와 & 비트연산 실행

0이 아닌 이상 해당 개발자 레코드 출력(0이 아니면 해당 개발자는 Front End 기술을 하나 이상 가지고 있다는 의미)
SUM으로 개발자 레코드 하나 당 한 번만 연산하기 때문에 중복 처리 필요 없음.

✅ 정답

1️⃣ 가상테이블

WITH FRONTEND AS (
    SELECT CODE FROM SKILLCODES
    WHERE CATEGORY = "Front End"
)

SELECT DISTINCT D.ID, D.EMAIL, D.FIRST_NAME, D.LAST_NAME FROM DEVELOPERS AS D
JOIN FRONTEND AS F
ON D.SKILL_CODE & F.CODE
ORDER BY D.ID;

2️⃣ 가상테이블 x, 서브쿼리

SELECT DISTINCT D.ID, D.EMAIL, D.FIRST_NAME, D.LAST_NAME FROM DEVELOPERS AS D
JOIN (SELECT CODE FROM SKILLCODES
      WHERE CATEGORY = "Front End"
     ) AS S
ON D.SKILL_CODE & S.CODE
ORDER  BY D.ID;

3️⃣ DISTINCT 사용 x

SELECT D.ID, D.EMAIL, D.FIRST_NAME, D.LAST_NAME FROM DEVELOPERS AS D
WHERE D.SKILL_CODE & (SELECT SUM(CODE) FROM SKILLCODES 
                      WHERE CATEGORY = "Front End")
ORDER BY D.ID;

[백준 : 골드3] Java BJ1520 내리막 길

굼벵욤 — Sun, 5 May 2024 09:00:24 +0900

#️⃣문제

여행을 떠난 세준이는 지도를 하나 구하였다. 이 지도는 아래 그림과 같이 직사각형 모양이며 여러 칸으로 나누어져 있다. 한 칸은 한 지점을 나타내는데 각 칸에는 그 지점의 높이가 쓰여 있으며, 각 지점 사이의 이동은 지도에서 상하좌우 이웃한 곳끼리만 가능하다.

현재 제일 왼쪽 위 칸이 나타내는 지점에 있는 세준이는 제일 오른쪽 아래 칸이 나타내는 지점으로 가려고 한다. 그런데 가능한 힘을 적게 들이고 싶어 항상 높이가 더 낮은 지점으로만 이동하여 목표 지점까지 가고자 한다. 위와 같은 지도에서는 다음과 같은 세 가지 경로가 가능하다.

지도가 주어질 때 이와 같이 제일 왼쪽 위 지점에서 출발하여 제일 오른쪽 아래 지점까지 항상 내리막길로만 이동하는 경로의 개수를 구하는 프로그램을 작성하시오.

#️⃣ 입력

첫째 줄에는 지도의 세로의 크기 M과 가로의 크기 N이 빈칸을 사이에 두고 주어진다. 이어 다음 M개 줄에 걸쳐 한 줄에 N개씩 위에서부터 차례로 각 지점의 높이가 빈 칸을 사이에 두고 주어진다. M과 N은 각각 500이하의 자연수이고, 각 지점의 높이는 10000이하의 자연수이다.

#️⃣ 출력

첫째 줄에 이동 가능한 경로의 수 H를 출력한다. 모든 입력에 대하여 H는 10억 이하의 음이 아닌 정수이다.

✅ 풀이 Point

현재 자신의 칸보다 작은 칸만 이동 가능하기 때문에 이전의 위치로 다시 이동할 수 없어 중복처리가 필요없다고 생각했다. 그래서 boolean[][] visited를 처음에는 사용하지 않았다.

하지만, 위의 예시의 사진을 봤을 때도 도착점까지 중복되는 경로가 존재한다. 그래서 이미 도착점까지의 경로의 개수가 계산되어있는 지점에서 도착점까지 다시 갈 필요가 없다.

그렇기 때문에 DFS와 DP를 사용하여 이미 도착점까지의 경로의 개수가 계산된 지점이라면 계산된 값을 반환하여 중복 탐색을 방지한다.

1️⃣ 도착점까지의 새로운 경로라면 1을 반환

if (ci == N - 1 && cj == M - 1) return 1; // 도착점까지 올 수 있는 새로운 경로

2️⃣ 이미 방문한 지점(도착점까지의 경로의 개수가 계산된 지점)이라면 해당 위치의 DP값 반환

if (dp[ci][cj] != -1) return dp[ci][cj]; // 이미 도착점까지의 경로가 정리된 dp[ci][cj] 반환

3️⃣ 1️⃣ & 2️⃣에 해당하지 않는 경우라면 인접한 상하좌우의 지점 중 이동가능한 경로 DFS을 통해 해당 지점의 DP[ci][cj] 값 완성

DFS를 통해서 해당 지점의 DP 값을 완성하고 있기 때문에 DP값을 0으로 초기 설정해놓을 경우, 이미 방문한 지점인지 판단할 수 없기 때문에 DP 초기값은 -1로 설정함.

dp = new int[N][M]; // 방문 처리, 경로 중복 탐색 방지용
for (int i = 0; i < N; i++) {
    ...
    for (int j = 0; j < M; j++) {
        ...
        dp[i][j] = -1;
    }
}

dp[ci][cj] = 0; // ci, cj 방문 처리
for (int i = 0; i < 4; i++) {
    int ni = ci + di[i];
    int nj = cj + dj[i];
    if (0 <= ni && ni < N && 0 <= nj && nj < M && arr[ni][nj] < arr[ci][cj]) {
        dp[ci][cj] += dfs(ni, nj);
    }
}

return dp[ci][cj];

<갈림길 [0][3]까지의 dp 상태>

<갈림길 [0][3] → [0][4]로 이동해서 도착지까지 이동했을 때 dp 상태>

<갈림길[0][3] → [1][3]으로 이동해서 도착지까지 이동했을 때 dp 상태>

<최종 dp 상태>

✅ 정답

import java.io.*;
import java.util.*;

public class Main {
    static int N, M;
    static int[][] arr;
    static int[][] dp; // [i][j] 현재 위치 i, j에서 도착점 N-1, M-1까지의 경로의 개수

    static int[] di = {-1, 0, 1, 0};
    static int[] dj = {0, 1, 0, -1};

    static class Node {
        int i;
        int j;

        public Node(int i, int j) {
            this.i = i;
            this.j = j;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine().strip());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        arr = new int[N][M];
        dp = new int[N][M]; // 방문 처리, 경로 중복 탐색 방지용
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine().strip());
            for (int j = 0; j < M; j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
                dp[i][j] = -1;
            }
        }

        System.out.println(dfs(0, 0));
    }

    private static int dfs(int ci, int cj) {
        if (ci == N - 1 && cj == M - 1) return 1; // 도착점까지 올 수 있는 새로운 경로
        if (dp[ci][cj] != -1) return dp[ci][cj]; // 이미 도착점까지의 경로가 정리된 dp[ci][cj] 반환

        dp[ci][cj] = 0; // ci, cj 방문 처리
        for (int i = 0; i < 4; i++) {
            int ni = ci + di[i];
            int nj = cj + dj[i];
            if (0 <= ni && ni < N && 0 <= nj && nj < M && arr[ni][nj] < arr[ci][cj]) {
                dp[ci][cj] += dfs(ni, nj);
            }
        }

        return dp[ci][cj];
    }
}

[CS : Network] 로드밸런싱

굼벵욤 — Tue, 9 Apr 2024 09:00:28 +0900

로드밸런싱(= 부하 분산)

처리해야 할 업무나 요청을 중앙처리장치 또는 저장 장치와 같은 컴퓨터 자원에 작업을 분산하는 것
→ 클라이언트의 요청을 일관성 있게 응답하기 위해 외부로부터 들어오는 요청을 서버에 적절히 배분하여 요청을 처리함.

로드밸런서
: 클라이언트의 요청 및 네트워크의 트래픽이 집중되는 서버들(Server Pool, Server Farm) 또는 네트워크 허브
사이에 위치하여, 특정 서버 또는 네트워크 허브에 부하가 집중되지 않도록 트래픽을 분산시키는 역할

기능

✅ Health Check(상태 확인)

서버들에 대한 주기적인 Health Check를 통해 서버들의 장애 여부를 판단하여, 정상 동작 중인 서버로만 트래픽을 보냄.
ex1) L3 체크 : ICMP를 이용하여 서버의 IP 주소가 통신 가능한 상태인지를 확인함.

더보기
ICMP(Internet Control Message Protocol)
: 패킷 전송에 실패했을 때 에러가 났음을 알림과 동시에, 해결 가능한 힌트를 제공하는 메시지 프로토콜

ex2) L4 체크 : TCP 특성을 기반으로 각 포트 상태를 확인하는 방식
ex3) L7 체크 : 실제 웹페이지에 통신을 시도하여 이상 유무를 파악함.

✅ Tunneling(터널링)

데이터 스트림을 인터넷 상에서 가상의 파이프를 통해 전달시키는 기술로, 패킷 내에 터널링할 대상을 캡슐화시켜 목적지까지 전송
연결된 상호 간에만 캡슐화된 패킷을 구별해 캡슐화를 해제하게 함.

✅ NAT(Network Address Translation)

내부 네트워크에서 사용하는 사설 IP 주소와 로드밸런서 외부의 공인 IP 주소 간의 변환 역할
로드밸런싱 관점에서 여러 개의 호스트가 하나의 공인 IP 주소를 통해 접속하는 것이 주 목적

더보기
SNAT(Source Network Address Translation)
: 내부에서 외부로 트래픽이 나가는 경우 내부 사설 IP 주소 → 외부 공인 IP 주소

DNAT(Destination Network Address Translation)
: 외부에서 내부로 트래픽이 들어오 경우 외부 공인 IP 주소 → 내부 사설 IP 주소

✅ DSR(Destination Network Address Translation)

서버에서 클라이언트로 트래픽이 되돌아갈 때, 목적지를 클라이언트로 설정한 다음, 네트워크 장비나 로드밸런서를 거치지 않고 바로 클라이언트를 찾아가는 방식
→ 로드밸런서의 부하 감소

알고리즘

✅ 라운드 로빈(Round Robin)

서버로 들어온 요청을 순서대로 돌아가며 배정하는 방식
클라이언트의 요청을 순서대로 분배하기 때문에 서버들이 동일한 스펙을 가지고 있고, 서버와의 연결이 오래 지속되지 않는 경우 활용하기 적합함.

✅ 가중 라운드 로빈(Weighted Round Robin Method)

각각의 서버마다 가중치를 매기고 가중치가 높은 서버에 클라이언트 요청을 우선적으로 배분함.
서버의 트래픽 처리 능력이 상이한 경우 사용되는 방식

✅ IP 해시

클라이언트의 IP 주소를 특정 서버로 매핑하여 요청을 처리하는 방식
사용자의 IP를 해싱하여 부하를 분산하기 때문에 사용자가 항상 동일한 서버로 연결되는 것을 보장함.
경로가 보장되고 접속자 수가 많을수록 분산 및 효율 좋음.

✅ 최소 연결

요청이 들어온 시점에 가장 적은 연결 상태를 보이는 서버에 우선적으로 트래픽을 할당
자주 세션이 길어지거나, 서버에 분배된 트래픽들이 일정하지 않은 경우 적합함.

✅ 최소 응답시간

서버의 현재 연결 상태와 응답시간을 모두 고려하여, 가장 짧은 응답 시간을 보내는 서버로 트래픽을 할당하는 방식
각 서버의 가용한 리소스와 성능, 처리중인 데이터 양 등이 상이할 경우 적합함.

✅ 대역폭

서버들과의 대역폭을 고려하여 서버에 트래픽을 할당

참고 블로그

https://co-no.tistory.com/22

[네트워크] 로드밸런싱의 개념 및 기법 설명

로드밸런싱(Load Balancing)이란? : 컴퓨터 네트워크 기술의 일종으로 둘 혹은 셋 이상의 중앙처리장치 혹은 저장장치와 같은 컴퓨터 자원들에게 작업(Work), 즉, 부하(Load)를 나누는 것을 의미한다. 이

co-no.tistory.com

https://velog.io/@yanghl98/OS%EC%9A%B4%EC%98%81%EC%B2%B4%EC%A0%9C-%EB%A1%9C%EB%93%9C%EB%B0%B8%EB%9F%B0%EC%8B%B1-Load-Balancing-%EC%A0%95%EC%9D%98-%EC%A2%85%EB%A5%98-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98

[Network/네트워크] 로드밸런싱 (Load Balancing) - 정의, 종류, 알고리즘

네트워크 또는 서버에 가해지는 로드를 분산 해주는 기술중앙처리장치 혹은 저장장치와 같은 컴퓨터 자원들에게 작업을 나누는 것을 의미로드밸런싱은 여러 대의 서버를 두고 서비스를 제공하

velog.io

[프로그래머스 : JOIN] 주문량이 많은 아이스크림들 조회하기

굼벵욤 — Fri, 22 Mar 2024 09:00:57 +0900

#️⃣ 문제 설명

다음은 아이스크림 가게의 상반기 주문 정보를 담은 [FIRST_HALF] 테이블과 7월의 아이스크림 주문 정보를 담은 [JULY] 테이블입니다. [FIRST_HALF] 테이블 구조는 다음과 같으며, SHIPMENT_ID, FLAVOR, TOTAL_ORDER는 각각 아이스크림 공장에서 아이스크림 가게까지의 출하 번호, 아이스크림 맛, 상반기 아이스크림 총주문량을 나타냅니다. [FIRST_HALF] 테이블의 기본 키는 FLAVOR 입니다. [FIRST_HALF] 테이블의 SHIPMENT_ID는 [JULY] 테이블의 SHIPMENT_ID의 외래 키입니다.

NAME	TYPE	NULLABLE
SHIPMENT_ID	INT(N)	FALSE
FLAVOR	VARCHAR(N)	FALSE
TOTAL_ORDER	INT(N)	FALSE

[JULY] 테이블의 구조는 다음과 같으며, SHIPMENT_ID, FLAVOR, TOTAL_ORDER 은 각각 아이스크림 공장에서 아이스크림 가게까지의 출하 번호, 아이스크림 맛, 7월 아이스크림 총주문량을 나타냅니다. [JULY] 테이블의 기본 키는 SHIPMENT_ID 입니다. [JULY] 테이블의 FLAVOR 는 [FIRST_HALF] 테이블의 FLAVOR 의 외래 키입니다. 7월에는 아이스크림 주문량이 많아 같은 아이스크림에 대하여 서로 다른 두 공장에서 아이스크림 가게로 출하를 진행하는 경우가 있습니다. 이 경우 같은 맛의 아이스크림이라도 다른 출하 번호를 갖게 됩니다.

NAME	TYPE	NULLABLE
SHIPMENT_ID	INT(N)	FALSE
FLAVOR	VARCHAR(N)	FALSE
TOTAL_ORDER	INT(N)	FALSE

#️⃣ 문제

7월 아이스크림 총 주문량과 상반기의 아이스크림 총 주문량을 더한 값이 큰 순서대로 상위 3개의 맛을 조회하는 SQL 문을 작성해주세요.

#️⃣ 예시

예를 들어 [FIRST_HALF] 테이블이 다음과 같고

SHIPMENT_ID	FLAVOR	TOTAL_ORDER
101	chocolate	3200
102	vanilla	2800
103	mint_chocolate	1700
104	caramel	2600
105	while_chocolate	3100
106	peach	2450
107	watermelon	2150
108	mango	2900
109	strawberry	3100
110	melon	3150
111	orange	2900
112	pineapple	2900

[JULY] 테이블이 다음과 같다면

SHIPMENT_ID	FLAVOR	TOTAL_ORDER
101	chcolate	520
102	vanilla	560
103	mint_chocolate	400
104	caramel	460
105	white_chocolate	350
106	peach	500
107	watermelon	780
108	mango	790
109	strawberry	520
110	melon	400
111	orange	250
112	pineapple	200
208	mango	110
209	strawberry	220

7월 아이스크림 총주문량과 상반기의 아이스크림 총 주문량이 더한 값이 큰 순서대로 상위 3개의 맛을 조회하면 strawberry(520 + 220 + 3,100 = 3,840), mango(790 + 110 + 2,900 = 3,800), chocolate(520 + 3,200 = 3,720) 순입니다. 따라서 SQL 문을 실행하면 다음과 같이 나와야 합니다.

FLAVOR

strawberry

mango

chocolate

✅ 풀이 Point

1️⃣ [JULY] 테이블, 맛 중복으로 존재함. 따라서 맛별로 [JULY] 테이블의 TOTAL_ORDER 구해 JOIN

SELECT FLAVOR, SUM(TOTAL_ORDER) AS TOTAL_ORDER FROM JULY
 GROUP BY FLAVOR

2️⃣ 총 주문량이 많은 순으로 상위 3개의 레코드 추출 → ORDER BY DESC, LIMIT

ORDER BY (H.TOTAL_ORDER + J.TOTAL_ORDER) DESC
LIMIT 3;

✅ 정답

SELECT H.FLAVOR FROM FIRST_HALF AS H
JOIN (SELECT FLAVOR, SUM(TOTAL_ORDER) AS TOTAL_ORDER FROM JULY
     GROUP BY FLAVOR) AS J
ON H.FLAVOR = J.FLAVOR
ORDER BY (H.TOTAL_ORDER + J.TOTAL_ORDER) DESC
LIMIT 3;

[CS : Network] TLS/SSL HandShake

굼벵욤 — Thu, 21 Mar 2024 09:00:44 +0900

TLS/SSL HandShake

SSL Handshake
: 통신을 하는 브라우저와 웹 서버가 서로 암호화 통신을 시작할 수 있도록 신분을 확인하고 필요한 정보를 클라이언트와 서버와 주고 받는 과정이 악수와 비슷하다하여 붙여짐.

SSL

대칭키 + 비대칭키 방식 섞어서 사용함.

✅파란색 칸

SYN, SYN ACK, ACK TCP 레이어의 3-way handshake로, HTTPS가 TCP 기반의 프로토콜이므로 SSL Handshake에 앞서 연결 생성을 위해 실시되는 과정

✅노란색 칸(SSL Handshake)

CA(Certificate authority or Root Certificate)
역할 : 클라이언트가 접속한 서버가 의도한 서버가 맞는지 보장

SSL 인증서 = 서비스의 정보(인증서를 발급한 CA, 서비스의 도메인 등) + 서버 측 공개키

클라이언트가 사용할 공개 키는 인증서 안에 담겨 있는데 클라이언트는 CA의 개인 키로 암호화 된 인증서를 어떻게 복호화시킬까?
: 우리가 사용하는 일반적인 브라우저에 신뢰할 수 있는 CA 기관의 리스트와 해당 기관의 공개키를 이미 가지고 있음. 클라이언트는 내장된 CA의 공개 키를 활용해 인증서를 복호화하여 인증서를 검증하고 서버의 공개키를 가져올 수 있음.

ClientHello
- 클라이언트가 서버에 연결을 시도하며 전송하는 패킷
- 사용 가능한 Cipher Suite 목록, Session ID, SSL 프로토콜 버전, Random Byte 등을 전달함.
- Cipher Suite : SSL 프로토콜 버전, 인증서 검정, 데이터 암호화 프로토콜, Hash 방식 등의 정보를 담고 있는 존재로, 선택된 Cipher Suite의 알고리즘에 따라 데이터를 암호화함.

ServerHello
- 클라이언트가 보내 온 ClientHello 패킷을 받아 Cipher Suite 중 하나를 선택한 다음 서버의 SSL 프로토콜 버전 등을 포함하여 클라이언트에게 알림.

Server Key Exchange
- 서버의 공개 키가 SSL 인증서 내부에 없는 경우, 서버가 직접 전달함.
- 공개 키가 SSL 인증서 내에 있을 경우 생략함.

ServerHello Done
- 공개 키가 SSL 인증서 내부에 있다면 클라이언트가 키를 통해 인증서를 복호화한 후 서버의 공개 키를 확보할 수 있음. → “서버가 행동을 마쳤음” 전달함.

Client Key Exchange
- 클라이언트, 데이터 암호화에 사용할 대칭 키(클라이언트와 서버가 실제로 교환할 데이터를 암호화하는 키)를 생성한 후 SSL 인증서 내부에서 추출한 서버의 공개 키를 이용해 암호화한 후 서버에게 전달함.

ChangeCipherSpec
- 클라이언트와 서버 모두가 서로에게 보내는 패킷으로, 교환할 정보를 모두 교환한 뒤 통신할 준비가 다 되었음을 알리는 패킷

Finished
- SSL Handshake를 종료함.

SSL Handshake 흐름 요약

서버는 CA에 사이트 정보와 공개 키를 전달하여 인증서를 받음.

➡️ 클라이언트는 브라우저에 CA 공개 키가 내장되어 있다고 가정

➡️ ClientHello(암호화 알고리즘 나열 및 전달)

➡️ ServerHello(암호화 알고리즘 선택) 

➡️ Server Certificate(인증서 전달)

➡️ Client Key Exchange(데이터를 암호화 할 대칭 키 전달) 

➡️ Client / ServerHello done (정보 전달 완료)

➡️ Finished(SSL Handshake 종료)

참고 블로그

https://aws-hyoh.tistory.com/39

HTTPS 통신과정 쉽게 이해하기 #3(SSL Handshake, 협상)

고대 그리스에서는 타인에게 노출되어서는 안 될 중요한 정보를 보낼 때, 전달하는 이(사자)의 머리를 빡빡 깎아서 중요한 정보를 적은 후 머리가 자라서 글이 보이지 않으면 그제야 상대방에게

aws-hyoh.tistory.com

https://steady-coding.tistory.com/512

[네트워크] TLS & SSL Handshake

cs-study에서 스터디를 진행하고 있습니다. SSL Handshake란? Handshake는 악수를 의미하는데, 통신을 하는 브라우저와 웹 서버가 서로 암호화 통신을 시작할 수 있도록 신분을 확인하고 필요한 정보를

steady-coding.tistory.com

[백준 : 골드 5] Java BJ2493 탑

굼벵욤 — Wed, 20 Mar 2024 09:00:21 +0900

#️⃣문제

KOI 통신연구소는 레이저를 이용한 새로운 비밀 통신 시스템 개발을 위한 실험을 하고 있다. 실험을 위하여 일직선 위에 N개의 높이가 서로 다른 탑을 수평 직선의 왼쪽부터 오른쪽 방향으로 차례로 세우고, 각 탑의 꼭대기에 레이저 송신기를 설치하였다. 모든 탑의 레이저 송신기는 레이저 신호를 지표면과 평행하게 수평 직선의 왼쪽 방향으로 발사하고, 탑의 기둥 모두에는 레이저 신호를 수신하는 장치가 설치되어 있다. 하나의 탑에서 발사된 레이저 신호는 가장 먼저 만나는 단 하나의 탑에서만 수신이 가능하다.

예를 들어 높이가 6, 9, 5, 7, 4인 다섯 개의 탑이 수평 직선에 일렬로 서 있고, 모든 탑에서는 주어진 탑 순서의 반대 방향(왼쪽 방향)으로 동시에 레이저 신호를 발사한다고 하자. 그러면, 높이가 4인 다섯 번째 탑에서 발사한 레이저 신호는 높이가 7인 네 번째 탑이 수신을 하고, 높이가 7인 네 번째 탑의 신호는 높이가 9인 두 번째 탑이, 높이가 5인 세 번째 탑의 신호도 높이가 9인 두 번째 탑이 수신을 한다. 높이가 9인 두 번째 탑과 높이가 6인 첫 번째 탑이 보낸 레이저 신호는 어떤 탑에서도 수신을 하지 못한다.

탑들의 개수 N과 탑들의 높이가 주어질 때, 각각의 탑에서 발사한 레이저 신호를 어느 탑에서 수신하는지를 알아내는 프로그램을 작성하라.

#️⃣ 입력

첫째 줄에 탑의 수를 나타내는 정수 N이 주어진다. N은 1 이상 500,000 이하이다. 둘째 줄에는 N개의 탑들의 높이가 직선상에 놓인 순서대로 하나의 빈칸을 사이에 두고 주어진다. 탑들의 높이는 1 이상 100,000,000 이하의 정수이다.

#️⃣ 출력

첫째 줄에 주어진 탑들의 순서대로 각각의 탑들에서 발사한 레이저 신호를 수신한 탑들의 번호를 하나의 빈칸을 사이에 두고 출력한다. 만약 레이저 신호를 수신하는 탑이 존재하지 않으면 0을 출력한다.

✅ 풀이 Point

1️⃣ 레이저를 수신하는 탑의 번호를 알아야하기 때문에 idx(탑의 순서), h(높이)를 속성으로 가진 Tower 클래스 필요함.

Stack을 사용할 때 스택의 크기가 현재 stack.peek()의 탑의 번호가 될 수 없기 때문에 Tower 클래스 필요함.

static class Tower {
    int idx;
    int h;

    public Tower(int idx, int h) {
        this.idx = idx;
        this.h = h;
    }
}

2️⃣ 아래와 같은 조건 분기 필요함.

현재 stack.peek().h 보다 h가 작을 경우, stack.peek() 부딪히므로 sb에 append 후 stack에 추가함.
stack.peek().h 보다 h가 클 경우, 부딪힐 때까지 stack.pop()
- stack안에 원소가 존재할 때만 돌아야하기 때문에 while문의 조건, !stack.isEmpty()
- stack안에 원소를 pop()해도 상관없는 이유는 앞에서 부터 입력을 받기 때문에, pop()된 경우 이전까지 입력된 탑의 높이들이 stack 안에 들어있는 모든 탑의 높이보다 크단 말이기 때문에 부딪히지 않아서 0이 정답

while (!stack.isEmpty()) {
    if (h < stack.peek().h) {
        sb.append(stack.peek().idx + " ");
        stack.add(new Tower(i, h));
        break;
    } else stack.pop();
}

if (stack.isEmpty()) {
    sb.append("0 ");
    stack.add(new Tower(i, h));
}

✅ 정답

heap을 이용해 거꾸로 입력받아서 푸는 것도 가능함.

import java.io.*;
import java.util.*;

public class Main {
    static class Tower {
        int idx;
        int h;

        public Tower(int idx, int h) {
            this.idx = idx;
            this.h = h;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        Stack<Tower> stack = new Stack<>();

        StringBuilder sb = new StringBuilder();
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            int h = Integer.parseInt(st.nextToken());
            if (stack.isEmpty()) {
                sb.append("0 ");
                stack.add(new Tower(i, h));
            } else {
                while (!stack.isEmpty()) {
                    if (h < stack.peek().h) {
                        sb.append(stack.peek().idx + " ");
                        stack.add(new Tower(i, h));
                        break;
                    } else stack.pop();
                }

                if (stack.isEmpty()) {
                    sb.append("0 ");
                    stack.add(new Tower(i, h));
                }
            }
        }
        System.out.println(sb);
    }
}

[백준 : 실버 2] Java BJ20006 랭킹전 대기열

굼벵욤 — Tue, 19 Mar 2024 09:00:06 +0900

#️⃣문제

종운이는 운영하던 게임에 랭킹전 기능을 추가하려고 한다. 플레이어 간의 실력차이가 있을 수 있기 때문에 입장을 신청하면 자신과 비슷한 레벨의 플레이어들을 매칭하여 게임을 시작하게 하려고 한다.

플레이어 간 매칭을 해주는 시스템은 다음과 같다.

플레이어가 입장을 신청하였을 때 매칭이 가능한 방이 없다면 새로운 방을 생성하고 입장시킨다. 이때 해당 방에는 처음 입장한 플레이어의 레벨을 기준으로 -10부터 +10까지 입장 가능하다.
입장 가능한 방이 있다면 입장시킨 후 방의 정원이 모두 찰 때까지 대기시킨다.
(이때 입장이 가능한 방이 여러 개라면 먼저 생성된 방에 입장한다.)
방의 정원이 모두 차면 게임을 시작시킨다.

플레이어 수 p, 플레이어의 닉네임 n, 플레이어의 레벨 l, 방 한 개의 정원 m이 주어졌을 때, 위와 같은 방법으로 매칭해주고 최종적으로 만들어진 방의 상태와 입장 플레이어들을 출력하는 프로그램을 작성하자.

#️⃣ 입력

첫 번째 줄에는 플레이어의 수 p(1 ≤ p ≤ 300)와 방의 정원 m(1 ≤ m ≤ 300)가 주어진다.
두 번째 줄부터 p개의 줄에는 플레이어의 레벨 l (1 ≤ l ≤ 500)과 닉네임 n이 공백을 두고 주어진다.
입력된 순서대로 게임을 시작한다.
닉네임은 중복되지 않으며 공백을 포함하지 않는 알파벳 소문자로 되어있으며 닉네임의 길이는 16을 넘지 않는다.

#️⃣ 출력

모든 생성된 방에 대해서 게임의 시작 유무와 방에 들어있는 플레이어들의 레벨과 아이디를 출력한다. 시작 유무와 플레이어의 정보들은 줄 바꿈으로 구분되며 레벨과 아이디는 한 줄에서 공백으로 구분된다.
방은 생성된 순서대로 출력한다.
방에 있는 플레이어들의 정보는 닉네임이 사전순으로 앞서는 플레이어부터 출력한다.
방이 시작되었으면 Started!를 대기 중이면 Waiting!을 출력시킨다.

✅ 풀이 Point

1️⃣ 대기방이 몇 개 이상 생길 지 모르기 때문에 ArrayList로 선언함.

ArrayList<ArrayList<Player>> 로 구성하여 ArrayList내부에는 Player를 가지는 ArrayList로 구현함.

ArrayList<ArrayList<Player>> rooms = new ArrayList<>();

각 대기방의 들어있는 선수들은 닉네임 사전 순으로 출력해야하기 때문에 Player 클래스 다음과 같이 구현함.

public static class Player implements Comparable<Player> {
    int level;
    String name;

    public Player(int level, String name) {
        this.level = level;
        this.name = name;
    }

    @Override
    public int compareTo(Player o) {
        return this.name.compareTo(o.name); // 문자열 정렬
    }
}

2️⃣ rooms 순차적으로 돌면서 room의 size가 m이 되면 대기방이 꽉찬 것이므로 다음 대기방 탐색

현재 존재하고 있는 대기방이 모두 선수로 가득찼을 경우 새 대기방을 만들어야하기 때문에 boolean변수 flag를 사용하여 판단함.

for (int i = 0; i < p; i++) {
    st = new StringTokenizer(br.readLine());
    int level = Integer.parseInt(st.nextToken());
    String name = st.nextToken();

    if (rooms.size() == 0) {
        rooms.add(new ArrayList<>());
        rooms.get(0).add(new Player(level, name));
        continue;
    }

    boolean flag = false; // 유저가 방을 배정받으면 true
    for (int j = 0; j < rooms.size(); j++) {
        if (rooms.get(j).size() == m) continue;

        int referenceLevel = rooms.get(j).get(0).level;
        if (referenceLevel - 10 <= level && level <= referenceLevel + 10) {
            flag = true;
            rooms.get(j).add(new Player(level, name));
            break;
        }
    }

    if (!flag) {
        rooms.add(new ArrayList<>());
        rooms.get(rooms.size() - 1).add(new Player(level, name));
    }
}

✅ 정답

import java.io.*;
import java.util.*;

public class Main {
    public static class Player implements Comparable<Player> {
        int level;
        String name;

        public Player(int level, String name) {
            this.level = level;
            this.name = name;
        }

        @Override
        public int compareTo(Player o) {
            return this.name.compareTo(o.name); // 문자열 정렬
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int p = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken()); // 방의 정원

        ArrayList<ArrayList<Player>> rooms = new ArrayList<>();
        for (int i = 0; i < p; i++) {
            st = new StringTokenizer(br.readLine());
            int level = Integer.parseInt(st.nextToken());
            String name = st.nextToken();

            if (rooms.size() == 0) {
                rooms.add(new ArrayList<>());
                rooms.get(0).add(new Player(level, name));
                continue;
            }

            boolean flag = false; // 유저가 방을 배정받으면 true
            for (int j = 0; j < rooms.size(); j++) {
                if (rooms.get(j).size() == m) continue;

                int referenceLevel = rooms.get(j).get(0).level;
                if (referenceLevel - 10 <= level && level <= referenceLevel + 10) {
                    flag = true;
                    rooms.get(j).add(new Player(level, name));
                    break;
                }
            }

            if (!flag) {
                rooms.add(new ArrayList<>());
                rooms.get(rooms.size() - 1).add(new Player(level, name));
            }
        }

        for (ArrayList<Player> room : rooms) {
            if (room.size() == m) System.out.println("Started!");
            else System.out.println("Waiting!");

            Collections.sort(room);
            for (Player player : room) System.out.println(player.level + " " + player.name);
        }
    }
}

[백준 : 골드 3] BJ14658 하늘에서 별똥별이 빗발친다

굼벵욤 — Sun, 17 Mar 2024 09:00:14 +0900

#️⃣문제

"오빠! 나 얼마만큼 사랑해?"

"널 위해서라면 저기 저 하늘의 별이라도 따다 줄 수 있어. 지금 따줄까?"

"에이, 거짓말!"

"정말이야. 한 번 봐봐!"

욱제는 하늘을 발로 차버렸다. 그랬더니 정말 별이 떨어졌다. 그런데, 정말로 별이 지구로 떨어지기 시작했다. 욱제는 지구를 지키는 정의의 용사가 되기로 결심했다.

"자기야, 나 세계를 지키고 올게. 꼭 돌아올 테니 조금만 기다려줘."

지구의 파괴를 막기 위해서는 지표면에 떨어지는 별똥별의 수를 최소화해야 한다. 욱제는 커다란 네모난 L x L 크기의 트램펄린으로 준비했다. 별똥별이 어디로 떨어질지는 이미 알고 있기 때문에, 욱제는 이 트램펄린으로 최대한 많은 별똥별을 우주로 튕겨낼 계획이다. 하지만 학교 예산으로 트램펄린을 구매하는 욱제는 이 긴급한 와중에도 예산 심의 통과를 기다리느라 바쁘다!

욱제를 도와 세계를 구하자. 최대한 많은 별똥별을 튕겨내도록 트램펄린을 배치했을 대, 지구에는 몇 개의 별똥별이 부딪히게 될까? (별똥별이 떨어지는 위치는 겹치지 않으며 별똥별은 트램펄린의 모서리에도 부딪혀도 튕겨나간다!) 트램펄린은 비스듬하게 배치 할 수 없다.

#️⃣ 입력

첫째 줄에 네 정수 N, M, L, K가 주어진다. (1 ≤ N, M ≤ 500,000, 1 ≤ L ≤ 100,000, 1 ≤ K ≤ 100) N은 별똥별이 떨어지는 구역의 가로길이, M은 세로길이, L은 트램펄린의 한 변의 길이, K는 별똥별의 수를 뜻한다. 이후 K개의 줄에 걸쳐 별똥별이 떨어지는 위치의 좌표 (x, y)가 주어진다. (0 ≤ x ≤ N, 0 ≤ y ≤ M)

#️⃣ 출력

욱제가 트램펄린으로 최대한 많은 별똥별을 튕겨낼 때, 지구에 부딪히는 별똥별의 개수를 출력한다.

✅ 풀이 Point

⛔ 완전탐색 문제 But, 입력값 500,000 → int[ ][ ] arr = new int[500_001][500_001]; 메모리 초과
슬라이딩 윈도우처럼 트램펄린이 설치될 수 있는 모든 구역 탐색시 시간 초과

⛔ 별 좌표를 중심으로 제 1, 2, 3, 4 사분면으로 나눠서 살펴볼 때 아래의 경우에는 탐색하지 못함.
트램펄린이 아래와 같이 위치할 경우, 모든 별 트램펄린 위에 있을 수 있음.

1️⃣ 트램펄린 위치 선정 → 트램펄린 위에 위치한 별 개수 확인

별이 최대한 트램펄린 모서리에 많이 위치할수록 좋음.
별의 개수가 100개 이하로 들어오기 때문에 별을 기준으로 완전 탐색
➡️ 트램펄린의 왼쪽 상단 꼭짓점의 위치 = (기준 별 x좌표, 다른 별 y좌표) 로 하여 모두 탐색
(아래의 그림 참고, 기준 별 좌표 = (4, 7))

// main function
int cnt = 0;
for (int i = 0; i < K; i++) {
    Node star1 = stars.get(i);
    for (int j = 0; j < K; j++) {
        Node star2 = stars.get(j);
        cnt = Math.max(countStar(star1.x, star2.y), cnt);
    }
}

private static int countStar(int x, int y) {
    int temp = 0;
    for (int k = 0; k < K; k++) {
        Node star = stars.get(k);
        // star는 x, y가 N, M을 넘지 않음. → x + L이 N보다 커지는 경우 고려할 필요 x
        if (x <= star.x && star.x <= x + L && y <= star.y && star.y <= y + L) temp++;
    }
    return temp;
}

✅ 정답

import java.io.*;
import java.util.*;

public class Main {
    static int N, M, L, K;
    static ArrayList<Node> stars = new ArrayList<>();

    static public class Node {
        int x;
        int y;

        public Node(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));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        L = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());

        for (int i = 0; i < K; i++) {
            st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());

            stars.add(new Node(x, y));
        }

        int cnt = 0;
        for (int i = 0; i < K; i++) {
            Node star1 = stars.get(i);
            for (int j = 0; j < K; j++) {
                Node star2 = stars.get(j);
                cnt = Math.max(countStar(star1.x, star2.y), cnt);
            }
        }
        System.out.println(K - cnt);
    }

    private static int countStar(int x, int y) {
        int temp = 0;
        for (int k = 0; k < K; k++) {
            Node star = stars.get(k);
            // star는 x, y가 N, M을 넘지 않음. → x + L이 N보다 커지는 경우 고려할 필요 x
            if (x <= star.x && star.x <= x + L && y <= star.y && star.y <= y + L) temp++;
        }
        return temp;
    }
}