기록방

BOJ_28470 : 슥~빡! 빡~슥!

Soom_1n — Tue, 26 Nov 2024 11:15:48 +0900

문제 분석

공격을 먼저했을 때와 회피를 먼저 했을 때 중에서 아드레날린의 최대값을 찾는다.

문제 풀이

Ki가 1보다 크면 Ai에 곱하고, 1이하면 Bi에 곱하면 최대값을 구할 수 있다.
Ki가 소수점 아래 첫째 자리까지 주어지는데, 소숫점 계산에 유의해야 한다.

코드

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

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));

        int N = Integer.parseInt(br.readLine());
        StringTokenizer st1 = new StringTokenizer(br.readLine());
        StringTokenizer st2 = new StringTokenizer(br.readLine());
        StringTokenizer st3 = new StringTokenizer(br.readLine());

        long sum = 0;

        for (int i = 0; i < N; i++) {
            int A = Integer.parseInt(st1.nextToken());
            int B = Integer.parseInt(st2.nextToken());
            float K = Float.parseFloat(st3.nextToken());

            if (K > 1) {
                sum += (int) (A * (K * 10) / 10) - B;
            } else {
                sum += A - (int) (B * (K * 10) / 10);
            }
        }

        bw.write(Long.toString(sum));
        bw.flush();
    }
}

코드 해석

Ki의 소수점 아래 첫째 자리를 정확하게 계산하기 위해, 10을 곱한 후 10을 나눠주는 작업이 필요하다.
Ai * Ki 혹은 Bi * Ki의 내림은 (int) 형 변환으로 처리했다.

end

오답률이 높길래 왜그런가 했더니 부동소수점의 오차를 깐깐히 보는 문제였다.
double형으로 곱셈 이후 내림을 수행하더라도 오차가 생기므로, 꼭 10을 곱하고 10을 나누는 작업을 통해 소수점 아래 첫째 자리를 정확히 계산하는게 중요했다.

BOJ_11068 : 회문인 수

Soom_1n — Mon, 25 Nov 2024 09:58:26 +0900

문제링크

문제 분석

입력된 수가 회문인 수(팰린드롬; palindrome) 인지 확인한다.
2부터 64 까지 기수 변환 시 회문인 수이면 1을, 아니라면 0을 반환한다.

문제 풀이

회문을 확인하기 위해 문자열 대칭 메서드를 구현한다.
64 자리 까지의 기수 변환을 구현한다.
- Integer.toString(숫자, 기수) 메서드는 최대 32 자리 기수 변환을 지원하기 때문에, 64 자리 까지 변환이 가능한 메서드를 직접 구현한다.
- 기수 변환을 위해 64개의 변환을 위한 문자가 필요하다.

코드

import java.io.*;

public class Main {
    private static final String DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@";

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringBuilder sb = new StringBuilder();

        int T = Integer.parseInt(br.readLine());

        for (int t = 0; t < T; t++) {
            int n = Integer.parseInt(br.readLine());

            sb.append(isHeaMoon(n) ? 1 : 0).append('\n');
        }

        bw.write(sb.toString());
        bw.flush();
    }

    private static boolean isHeaMoon(int n) {

        for (int i = 2; i <= 64; i++) {
            char[] chars = customBase(n, i).toCharArray();
            boolean flag = true;

            for (int j = 0; j <= chars.length / 2; j++) {
                if (chars[j] != chars[chars.length - j - 1]) {
                    flag = false;
                    break;
                }
            }

            if (flag) return true;
        }

        return false;
    }

    private static String customBase(int num, int base) {
        StringBuilder result = new StringBuilder();

        while (num > 0) {
            result.append(DIGITS.charAt(num % base));
            num /= base;
        }

        return result.reverse().toString();
    }
}

코드 해석

isHeaMoon() 메서드에서 입력된 수가 회문인지 확인한다.
- 2부터 64까지 기수 변환을 해보며 회문이면 1, 아니면 0을 반환한다.
customeBase() 메서드에서 기수 변환을 진행한다.
- DIGISTS 에 적힌 64개의 문자 중 하나로 변환하는 방식으로 구현한다.
- num을 base로 나눈 나머지 값을 누적한 후, 뒤집어 반환한다.

end

처음에는 간단히 Integer.toString()으로 구현하는 줄 알았다.
- 기수 변환을 32까지만 지원한다는 것을 처음 알았다.
- Java 공식 문서를 보면 toString()에 대한 설명과 기수(radix)의 최대값과 최소값 설명이 적혀있다.

BOJ_1854 : K번째 최단경로 찾기

Soom_1n — Thu, 26 Sep 2024 10:44:34 +0900

문제링크

문제 분석

1번 도시부터 다른 도시로 가는 K번째 최단 거리를 구해야 한다.
K번째 최단 경로가 없으면 -1 출력한다.

문제 풀이

한 노드부터 다른 노드까지의 최단 거리를 구하므로, 다익스트라 (Dijkstra) 알고리즘을 선택한다.
일반적인 다익스트라와 다르게, 거리를 업데이트이트 하지 않고 우선 순위 큐에 다시 넣는다.
무한 순환 혹은 너무 많은 원소가 생기지 않도록, K개 까지만 거리를 구한다.

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

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));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

        ArrayList<ArrayList<int[]>> adjList = new ArrayList<>();
        ArrayList<ArrayList<Integer>> dist = new ArrayList<>();

        for (int i = 0; i <= n; i++) {
            adjList.add(new ArrayList<>());
            dist.add(new ArrayList<>());
        }

        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            adjList.get(a).add(new int[]{b, c});
        }

        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));

        pq.offer(new int[]{1, 0});

        while (!pq.isEmpty()) {
            int[] now = pq.poll();

            if (dist.get(now[0]).size() >= k) {
                continue;
            }

            dist.get(now[0]).add(now[1]);

            for (int[] a : adjList.get(now[0])) {
                pq.offer(new int[]{a[0], now[1] + a[1]});
            }
        }

        for (int i = 1; i <= n; i++) {
            if (dist.get(i).size() < k) {
                sb.append(-1).append('\n');
            } else {
                sb.append(dist.get(i).get(k - 1)).append('\n');
            }
        }

        bw.write(sb.toString());
        bw.flush();
    }
}

코드 해석

간선 정보를 저장하기 위한 인접 리스트 adjList를 사용했다.
K개의 최단 경로를 저장하기 위한 리스트 dist를 사용했다.
일반적인 방문 체크 대신, 최단 경로의 개수가 K개가 되지 않을 때 까지 다익스트라 알고리즘을 사용한다.

end

플레티넘 문제라고 많이 걱정했는데, 다익스트라 알고리즘을 조금만 변형하면 된다는 아이디어가 떠오른다면 금방 풀리는 문제였다.
나는 우선순위 큐에서 나오는 거리가 해당 노드까지 가는 '현재의 최단거리'로 생각하고 풀이했는데, 이게 최단 거리를 확실히 보장하는지는 의문이다. (백준 게시판에 질문을 남겨놨다.)
- 다른 풀이로 dist를 그냥 ArrayList가 아닌 우선 순위 큐의 배열로 구현하는 방법도 있었다. 이 경우엔 확실히 K번째 거리를 보장한다.
코드를 다듬으며 여러번 제출했는데, 알고리즘이 같으니 시간이나 메모리가 비슷하다. 근소한 수치 차이는 그냥 서버 상태의 차이인 것 같다.

BOJ_1948 : 임계경로

Soom_1n — Thu, 12 Sep 2024 16:48:38 +0900

문제링크

문제 분석

N개의 도시 사이 M개의 도로가 주어진다. 각 도로를 건너는 시간이 있고, 출발지와 도착지가 주어진다.
도로는 출발지부터 도착지까지 단방향 비순환 그래프이다.
많은 경로 중에 가장 늦게 도착하는 경로에서 지나는 도로의 수 총합을 출력한다.

문제 풀이

출발지부터 도착지까지 단방향 비순환 그래프이므로, 위상 정렬(Topology Sort)을 통해 최대값을 구할 수 있다.
건너온 경로의 수를 카운트 해야하므로 역방향 탐색이 필요하다.
- 1분도 쉬지 않고 달린 경로이므로 현재 시간과 도로의 소요 시간의 차이가 맞아 떨어져야 한다.
- 경로를 중복되게 체크하지 않기 위해서 도시를 방문처리 한다.

코드

import java.io.*;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Queue;
import java.util.StringTokenizer;

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));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st;

        int n = Integer.parseInt(br.readLine());
        int m = Integer.parseInt(br.readLine());
        int[] indegree = new int[n + 1];

        ArrayList<ArrayList<Edge>> adjList = new ArrayList<>();
        ArrayList<ArrayList<Edge>> adjList_reverse = new ArrayList<>();

        for (int i = 0; i <= n; i++) {
            adjList.add(new ArrayList<>());
            adjList_reverse.add(new ArrayList<>());
        }

        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int out = Integer.parseInt(st.nextToken());
            int in = Integer.parseInt(st.nextToken());
            int time = Integer.parseInt(st.nextToken());
            adjList.get(out).add(new Edge(in, time));
            adjList_reverse.get(in).add(new Edge(out, time));
            indegree[in]++;
        }

        st = new StringTokenizer(br.readLine());
        int start = Integer.parseInt(st.nextToken());
        int end = Integer.parseInt(st.nextToken());


        // 위상 정렬
        int[] critical_path = new int[n + 1]; // 걸린 시간의 최댓값
        Queue<Integer> que = new ArrayDeque<>();
        que.offer(start);

        while (!que.isEmpty()) {
            int now = que.poll();

            for (Edge next : adjList.get(now)) {
                critical_path[next.v] = Math.max(critical_path[next.v], critical_path[now] + next.time);
                if (--indegree[next.v] == 0) {
                    que.offer(next.v);
                }
            }
        }

        // 역방향 위상 정렬
        boolean[] visited = new boolean[n + 1];
        que.offer(end);
        int cnt = 0;

        while (!que.isEmpty()) {
            int now = que.poll();
            for (Edge next : adjList_reverse.get(now)) {
                if (critical_path[now] == critical_path[next.v] + next.time) {
                    cnt++;
                    if (!visited[next.v]) {
                        que.offer(next.v);
                        visited[next.v] = true;
                    }
                }
            }
        }

        sb.append(critical_path[end]).append('\n').append(cnt);
        bw.write(sb.toString());
        bw.flush();
    }

    private static class Edge {
        int v;
        int time;

        public Edge(int v, int time) {
            this.v = v;
            this.time = time;
        }
    }
}

코드 해석

진입 차수 int형 배열 indegree, 인접 리스트 adjList와 역방향 인접 리스트 adjList_reverse를 입력받는다.
먼저 위상 정렬을 통해 각 도시에 도착하는 최대 시간(임계 경로)를 구한다.
- 현재 도시에서 다음 도시로 가는 경로가 더 큰 값이면 업데이트 (DP 느낌)
- 다음 도시의 진입 차수를 -1 해주고, 만약 0이 되었다면 경로를 확인하기 위해 큐에 넣는다.
- 최종 도착지의 임계 경로 값이 도착까지 걸리는 최대 시간이다.
역방향 위상 정렬을 통해 건너온 간선의 수를 카운트한다.
- 순방향 위상 정렬과 다른 점은, 1분도 기다려서는 안되기 때문에 시간이 정확히 일치해야 한다.
  (다음 도시로 가는 시간 + 다음 도시 임계 경로값 = 현재 도시 임계 경로값)
- 일치한다면, 해당 경로가 지나온 길이므로 cnt+1
- 중복을 피하기 위해 방문 체크로 1번만 다음 도시를 큐에 넣는다.
- 총 카운트 된 cnt 값이 지나온 경로의 총합이다.

end

위상 정렬 알고리즘을 공부하며 최종으로 풀어본 어려운 문제인데...너무 어려웠다.
3시간은 잡고있던 것 같은데, 위상 정렬을 완벽히 이해하고, 그래프 문제에서 종종 나오는 역방향 탐색까지 필요로 했다.
알고리즘은 간단하다고 생각했는데, 활용 영역이 너무 다양해서 아직 한참 연습이 필요한 것 같다.

BOJ_1516 : 게임 개발

Soom_1n — Thu, 12 Sep 2024 12:22:43 +0900

문제링크

문제 분석

스타크레프트 같은 게임에서 각 건물을 짓는데 필요한 최소 시간을 구해보자.
N개의 건물 별 짓는 시간과 먼저 지어져야 하는 건물의 번호가 주어진다.

문제 풀이

선행 되어야 하는 번호가 주어지므로 위상 정렬(Topology Sort)을 활용해 풀이할 수 있다.
선행 건물 건설 직후 해당 건물을 짓는데, 선행 건물이 여러개일 경우 순서를 정할 수 없다.
따라서 선행 건물이 지어지는 시간의 최대값 + 현재 건물을 짓는 시간을 구한다.

코드

import java.io.*;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Queue;
import java.util.StringTokenizer;

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));
        StringBuilder sb = new StringBuilder();

        int N = Integer.parseInt(br.readLine());
        int[] d = new int[N + 1];
        int[] time = new int[N + 1];

        ArrayList<Integer>[] adjList = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) {
            adjList[i] = new ArrayList<>();
        }

        for (int i = 1; i <= N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            time[i] = a;

            while ((a = Integer.parseInt(st.nextToken())) > -1) {
                adjList[a].add(i);
                d[i]++;
            }
        }

        Queue<Integer> que = new ArrayDeque<>();
        int[] answer = new int[N + 1];

        for (int i = 1; i <= N; i++) {
            if (d[i] == 0) {
                que.offer(i);
                answer[i] = time[i];
            }
        }

        while (!que.isEmpty()) {
            int a = que.poll();
            for (int i : adjList[a]) {
                answer[i] = Math.max(answer[i], answer[a] + time[i]);
                if (--d[i] == 0) {
                    que.offer(i);
                }
            }
        }

        for (int i = 1; i <= N; i++) {
            sb.append(answer[i]).append('\n');
        }

        bw.write(sb.toString());
        bw.flush();
    }
}

코드 해석

N개의 건물의 지어지는 시간을 time, 진입 차수를 d 배열에 저장한다.
위상 정렬을 위해 간선 정보를 ArrayList 배열 adjList에 저장한다.
큐를 만들고, 현재 진입 차수가 0인 건물의 건설 시간을 바로 정답 배열 answer에 저장하고, 건물 번호는 큐에 넣는다.
큐가 빌 때까지 계산을 반복한다.
- 큐에서 나온 건물의 다음 건설 건물의 시간을 answer에 저장한다.
- 이때, 기존 건설 시간과 현재 건물 직후로 짓는 건설 시간 중 큰 값을 저장한다.
- 만약 진입 차수가 0이 되었다면 큐에 넣는다.
정답 배열에 저장 된 건설 시간을 출력한다.

end

부분적인 선행 작업 정보가 나왔으니, 위상 정렬이 바로 떠올랐다.
다만, 첫 풀이에서는 진입 차수가 0이 되었을때 answer[i]에 값을 저장하는 방식으로 했는데 틀렸다.
건물이 동시에 지어질 수 있으므로, 선행 작업 중 더 오래걸리는 값으로 계산해야 했다.

[후기] 프로그래머스 SQL역량인증(PCSQ) Lv3 취득

Soom_1n — Thu, 29 Aug 2024 19:08:12 +0900

프로그래머스에서 주관하는 자격증 중 하나인 PCSQL의 Lv2를 취득했다

왜 따고자 했더라

프로그래머스에는 현재 3가지 자격증이 있다. (https://certi.programmers.co.kr/)

먼저 PCCP는 코딩전문역량인증시험으로 어려운 난이도의 코딩 자격증이고,
CCE는 코딩필수역량인증시험으로 쉬운 난이도의 기초 코딩 자격증이다.

그 밖에도 최근에 생긴 SQL 관련 PCSQL 자격증도 생겼는데 이전 PCCP 취득 후 취준 겸 따보고자 했다. (https://soooom.tistory.com/488)

기업 코테에서 sql문제가 있는 경우가 종종있는데, 난이도는 그렇게 어렵지 않기 때문에 Lv2를 목표로 했다.

PCSQL은 최근에 생겨서 그런지, 프로그래머스 프로필에 넣을 수 없다. 대신 인증시험페이지의 프로필에서 취득 목록을 확인할 수 있다.

준비 과정

먼저 SQL 고득점 Kit문제를 중심으로 풀어나갔다.

위에 나와있는 모든 문제를 풀려고 했는데, 면접 일정과 겹쳐서 그러진 못했다.

[SELECT], [SUM, MAX, MIN], [IS NULL], [String, Data]를 풀었는데, JOIN이나 GROUP BY는 기초적인 내용은 항상 등장했었다. 우선 문법에 익숙해지고, 쉬운걸 정확하고 빠르게 푸는 게 목적이었다.

그리고 인증 시험 페이지에서 샘플 문제 모의고사를 시험 전에 여러번 풀까 했었는데, 그냥 5문제 만 나오는 거였어서 풀이를 숙지하는 데에 의의가 있었다.

어느 날 갑자기 특강을 해준다며 프로그래머스에서 연락이 왔다.

취득률이 낮고 홍보가 잘 안돼서 그런지 이런 지원도 해주나 보다.

프로그래머스 캠퍼스의 특강 코스로 초대되었는데, 지금은 수강 기간이 지나서 접속할 수 없다.

Zoom으로 실시간 강의를 진행해 주셨는데, 김진환 강사님이셨고 위니브 소속인게 기억난다. (지원했다 떨어졌던...)

캠퍼스는 별 의미가 없었던게, 그냥 PCSQL에 대한 설명과 주의사항이 있었고 5문제를 풀 수 있게 표시되어 있었다.

하지만, 샘플문제의 모의고사 5문제와 똑같아서 사실상 특강을 듣지 않더라도 찾아볼 수 있던 정보들이었다.
(찾아보는 사람이 적어서 안내차 한 건지..)

대신, 특강의 문제 풀이는 정말 유용했던 것 같다. 1~3번은 혼자서도 풀 수 있었고, 4번 5번은 풀이 라인이 30줄, 50줄 나와서 깜짝 놀랐다...(실제 시험에서도 딱 3번까지만 풀 수 있었다 ㅜㅜ)

소감

그래도 결국 취득에 성공했다..! 1000점 중 딱 절반인 500점이었지만, 공부한 것과 목표치가 낮았던 것 치고는 선방했다.

Lv3까지 취득할 정도라면 기업 코테의 SQL 문제는 큰 어려움이 없을 것으로 생각된다.

다음에 시간이 남는다면 PCCE도 취득해 볼까 한다. 기초 내용이라 큰 의미는 없지만, Java의 이론 정리를 복습하는 느낌으로 해볼 생각이다.

BOJ_1113 : 수영장 만들기

Soom_1n — Tue, 20 Aug 2024 18:47:49 +0900

문제링크

문제 분석

N x M 직사각형 땅에 수영장을 만든다. 격자 속 숫자가 해당 땅의 높이이다.
물을 채워야 하는데, 물은 상하좌우 높은 곳에서 낮은 곳으로만 흐르고 격자 밖으로는 무한정 흘러나가 버린다.
채울 수 있는 물의 양의 최대값을 출력한다.

문제 풀이

상하좌우 인접 땅으로 흐르는 물의 이동을 구현하기 위해서 BFS를 사용한다.
외각에 붙은 땅은 물이 고일 수 없으므로, 역방향 BFS를 통해 이어진 땅들을 모두 체크한다.
물이 고일 수 있는 땅들에 물을 채우고 총합을 출력한다.
물 높이의 최대값은 2가지 기준을 유의해서 정한다.
1. 해당 높이보다 높아지면 물이 흘러나가버리는 경우 : 최대값의 인덱스가 체크된 경우
2. 흘러나가지는 않지만, 땅이 높아서 조금 더 높이 물이 고이는 경우 : 최대값의 인덱스가 체크되지 않은 경우

코드

import java.io.*;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    private static final int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 상하좌우
    private static int N, M;
    private static int[][] pool;
    private static boolean[][] visited;

    public static void main(String[] args) throws IOException {
        // Input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        pool = new int[N][M];
        visited = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            char[] chars = br.readLine().toCharArray();
            for (int j = 0; j < M; j++) {
                pool[i][j] = Character.getNumericValue(chars[j]);
            }
        }

        // BFS 1) 물을 부으면 안되는 곳은 true
        for (int i = 0; i < N; i++) {
            if (!visited[i][0]) {
                noWater_Upper(new Point(i, 0));
            }
            if (!visited[i][M - 1]) {
                noWater_Upper(new Point(i, M - 1));
            }
        }
        for (int i = 0; i < M; i++) {
            if (!visited[0][i]) {
                noWater_Upper(new Point(0, i));
            }
            if (!visited[N - 1][i]) {
                noWater_Upper(new Point(N - 1, i));
            }
        }

        // BFS 2) 채우는 물 양 카운트
        int cnt = 0;
        for (int i = 1; i < N - 1; i++) {
            for (int j = 1; j < M - 1; j++) {
                if (!visited[i][j]) {
                    cnt += cntPoolWater(new Point(i, j));
                }
            }
        }

        // Output
        bw.write(Integer.toString(cnt));
        bw.flush();
    }

    private static void noWater_Upper(Point start) { // 상승 방향으로 물을 못 담는 위치 표시
        Queue<Point> que = new ArrayDeque<>();
        que.add(start);
        visited[start.row][start.col] = true;
        while (!que.isEmpty()) {
            Point p = que.poll();
            for (int[] dir : dir) {
                int row = p.row + dir[0];
                int col = p.col + dir[1];
                if (0 <= row && row < N && 0 <= col && col < M
                        && !visited[row][col] && pool[row][col] >= pool[p.row][p.col]) {
                    visited[row][col] = true;
                    que.add(new Point(row, col));
                }
            }
        }
    }

    private static int cntPoolWater(Point start) { // 물이 고이는 최대 높이 반환
        int maxHeight = Integer.MAX_VALUE;

        Queue<Point> que = new ArrayDeque<>();
        Queue<Point> water = new ArrayDeque<>();
        boolean[][] flag = new boolean[N][M];

        que.add(start);
        water.add(start);
        flag[start.row][start.col] = true;

        while (!que.isEmpty()) { // 물 높이의 최대값 찾기
            Point p = que.poll();
            for (int[] dir : dir) {
                int row = p.row + dir[0];
                int col = p.col + dir[1];
                if (visited[row][col]) { // 물을 채우면 안되는 곳
                    if (pool[row][col] <= pool[p.row][p.col]) { // 채우면 안되는 곳인데 흘러감
                        noWater_Upper(new Point(row, col));
                        return 0;
                    }
                    maxHeight = Math.min(maxHeight, pool[row][col]);
                } else if (!flag[row][col] && pool[row][col] <= pool[p.row][p.col]) { // 시작 위치에 물 부우면 같이 참
                    flag[row][col] = true;
                    que.add(new Point(row, col));
                    water.add(new Point(row, col));
                } else if (pool[row][col] > pool[p.row][p.col])
                    maxHeight = Math.min(maxHeight, pool[row][col]);
            }
        }

        int cnt = 0;
        for (Point p : water) {
            if (maxHeight > pool[p.row][p.col]) {
                cnt += maxHeight - pool[p.row][p.col];
                pool[p.row][p.col] = maxHeight;
            }
        }

        return cnt;
    }

    private static class Point {
        int row, col;

        public Point(int row, int col) {
            this.row = row;
            this.col = col;
        }
    }
}

코드 해석

N x M 땅의 테두리는 물이 흘러나가버린다. 물이 흘러 들어오는 땅들도 모두 물을 채우면 안되는 땅이므로 역방향 BFS를 구현한 noWater_Upper() 메서드를 통해 visited를 true로 체크한다.
visited가 false인 나머지 땅들에 cntPoolWater() 메서드로 물을 채운다.
- 시작 위치에서 같거나 작은 높이로 이어진 땅들을 water 큐에 넣는다.
- 이때 주변 땅의 높이 중 가장 낮은 값을 max에 저장한다.
- 탐색이 끝나면, water에 저장 된 땅들에 max 만큼 물을 채운다.

end

상당히 어려웠고 시간이 많이 걸린 문제이다. BFS를 2종류로 나눠서 하고 역방향으로 하면 되겠다는 아이디어는 금방 나왔는데, 구상을 조금 이상하게 해서 테케를 많이 만들었어야 했다.
물을 채우는 cntPoolWater() 메서드의 BFS에서 탐색 범위를 visited가 false 경우로만 뒀었는데, 땅의 높이가 갖거나 낮은 경우라는 조건도 추가로 필요했다.
한 번 탐색한 땅은 배제하려고 했던게 큰 오점이었는데, 같은 칸이어도 물을 여러번 높여가는 방식으로 바꾸어서 해결되었다.
코드 디버깅에 시간이 너무 걸려서 리팩터링은 포기하고 좀 지저분한 형태의 답안으로 마무리되었다...

MySQL 기본 정리 : SELECT, FROM, WHERE, ORDER BY, LIMIT

Soom_1n — Sun, 18 Aug 2024 23:14:48 +0900

1. SELECT / FROM

목적 : 데이터베이스에서 특정 컬럼의 데이터를 조회

형태 : SELECT (속성1, 속성2, ...) FROM (테이블)

SELECT column1, column2, ...
FROM table_name;

column1, column2, ... : 조회할 컬럼
table_name : 데이터를 조회할 테이블의 이름

기타 사항

전체 컬럼 조회 : SELECT * FROM (테이블)
반환 값 모두 표시(기본설정) : SELECT ALL column1, column2, ... FROM (테이블)
선택 컬럼 중복 값 제거 : SELECT DISTINCT column1, column2, ... FROM (테이블)
컬럼에 별칭 부여 가능 : SELECT column1 as A, column2 as "B" , column3 C FROM (테이블)
컬럼에 함수 사용 가능 : SELECT COUNT(column1) FROM ~

예시

-- 예시 1: employees 테이블에서 모든 컬럼 조회
SELECT * 
FROM employees;

-- 예시 2: products 테이블에서 product_name과 price 컬럼 조회
SELECT product_name, price 
FROM products;

2. WHERE

목적 : 조회할 데이터에 대한 조건을 지정하여 특정 행만 조회

형태 : SELECT (속성1, 속성2, ...) FROM (테이블) WHERE (조건문)

SELECT column1, column2, ...
FROM table_name
WHERE condition;

condition: 데이터를 필터링하는 조건을 지정합니다.

기타 사항

조건문에 활용 가능한 것
- 비교 연산자 : =, <>, >, <, >=, <=
- 논리 연산자 : AND, OR, NOT
- BETWEEN : 범위 내의 값 검색
- IN : 여러 값 중 하나와 일치
- LIKE : 문자열 패턴 매칭
- IS NULL / IS NOT NULL : NULL 값 확인
- EXISTS : 서브쿼리의 결과 존재 여부 확인
- ANY / SOME : 서브쿼리의 결과 중 하나와 일치 여부 확인

예시

-- 비교 연산자 예시

-- = : department가 'Sales'인 직원 선택
SELECT * FROM employees
WHERE department = 'Sales';

-- <> 또는 != : department가 'HR'이 아닌 직원 선택
SELECT * FROM employees
WHERE department <> 'HR';

-- > : price가 100보다 큰 제품 선택
SELECT * FROM products
WHERE price > 100;

-- < : quantity가 10보다 작은 주문 선택
SELECT * FROM orders
WHERE quantity < 10;

-- >= : salary가 50,000 이상인 직원 선택
SELECT * FROM employees
WHERE salary >= 50000;

-- <= : price가 50 이하인 제품 선택
SELECT * FROM products
WHERE price <= 50;

-- 논리 연산자 예시

-- AND : department가 'Sales'이고 salary가 50,000 이상인 직원 선택
SELECT * FROM employees
WHERE department = 'Sales' AND salary > 50000;

-- OR : department가 'Sales' 또는 'Marketing'인 직원 선택
SELECT * FROM employees
WHERE department = 'Sales' OR department = 'Marketing';

-- NOT : department가 'HR'이 아닌 직원 선택
SELECT * FROM employees
WHERE NOT department = 'HR';

-- BETWEEN : price가 50 이상 150 이하인 제품 선택
SELECT * FROM products
WHERE price BETWEEN 50 AND 150;

-- IN : department가 'Sales', 'Marketing', 또는 'HR'인 직원 선택
SELECT * FROM employees
WHERE department IN ('Sales', 'Marketing', 'HR');

-- LIKE : product_name이 'A'로 시작하는 제품 선택
SELECT * FROM products
WHERE product_name LIKE 'A%';

-- IS NULL : manager_id가 NULL인 직원 선택
SELECT * FROM employees
WHERE manager_id IS NULL;

-- IS NOT NULL : manager_id가 NULL이 아닌 직원 선택
SELECT * FROM employees
WHERE manager_id IS NOT NULL;

-- EXISTS : employees 테이블의 department_id가 departments 테이블에 존재하는 경우
SELECT * FROM employees e
WHERE EXISTS (
    SELECT 1
    FROM departments d
    WHERE d.department_id = e.department_id
);

-- ANY : salary가 'Sales' 부서의 직원 중 하나가 가진 salary보다 큰 직원 선택
SELECT * FROM employees
WHERE salary > ANY (
    SELECT salary
    FROM employees
    WHERE department = 'Sales'
);

3. ORDER BY

목적: 조회된 데이터를 정렬. 기본적으로 오름차순으로 정렬하며, 내림차순 정렬도 가능

형태 : SELECT (속성1, 속성2, ...) FROM (테이블) [ WHERE (조건문) ] ORDER BY (속성) (정렬방식)

SELECT column1, column2, ... 
FROM table_name 
ORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...;

ASC: 오름차순 정렬 (기본값).
DESC: 내림차순 정렬.

기타 사항

column1에 컬럼 명 대신, 컬럼 순서 사용 가능 : ORDER BY 1, 2 DESC
column1에 컬럼 명 대신, 별칭 사용 가능 : ORDER BY A, B
랜덤 정렬 가능 : ORDER BY RAND()
정렬 기준
- 문자열 : ASCII 코드 또는 문자 집합 및 정렬 규칙에 따라 정렬
- 숫자 : 수치 값을 기준으로 정렬
- 날짜 및 시간 : 날짜와 시간의 순서에 따라 정렬
- NULL 값 : 기본적으로 정렬 시 마지막에 위치

예시

-- 예시 1: employees 테이블에서 salary를 내림차순으로 정렬
SELECT * 
FROM employees 
ORDER BY salary DESC;

-- 예시 2: products 테이블에서 price를 오름차순으로 정렬, 그리고 product_name으로 다시 정렬
SELECT * 
FROM products 
ORDER BY price ASC, product_name ASC;

4. LIMIT

목적: 조회된 결과에서 반환할 행의 수를 제한

형태 : SELECT (속성1, 속성2, ...) FROM (테이블) [ WHERE ~ ] [ ORDER BY ~ ] LIMIT (나타낼 갯수)

SELECT column1, column2, ...
FROM table_name
LIMIT number;

number : 반환할 행의 수를 지정

기타 사항

첫 행부터 몇 개의 행을 반환 할 것인지 지정
값이 큰 5개 반환 : ORDER BY length DESC LIMIT 5
최소값 반환 : ORDER BY length LIMIT 1

예시

-- 예시 1: products 테이블에서 상위 5개의 가장 비싼 제품 조회
SELECT * 
FROM products 
ORDER BY price DESC 
LIMIT 5;

-- 예시 2: orders 테이블에서 가장 오래된 3개의 주문 조회
SELECT * 
FROM orders 
ORDER BY order_date ASC 
LIMIT 3;

-- 예시 3: employees 테이블에서 department가 'HR'인 직원 중 상위 5명 조회
SELECT * 
FROM employees 
WHERE department = 'HR'
ORDER BY salary DESC 
LIMIT 5;

-- 예시 4: products 테이블에서 price가 50 이상인 제품 중 상위 10개 조회
SELECT * 
FROM products 
WHERE price >= 50 
ORDER BY price DESC 
LIMIT 10;

요약

SELECT: 조회할 컬럼을 지정
FROM: 데이터를 조회할 테이블을 지정
WHERE: 특정 조건을 만족하는 데이터만 조회
ORDER BY: 결과를 정렬
LIMIT: 결과의 행 수를 제한

BOJ_15989 : 1, 2, 3 더하기 4

Soom_1n — Fri, 16 Aug 2024 23:30:19 +0900

문제링크

문제 분석

1, 2, 3의 덧셈으로 n을 만들 수 있는 조합의 수를 출력한다.

문제 풀이

다이나믹 프로그래밍 문제로, dp[n]은 n을 만드는 조합의 수이다.
중복을 제거하기 위해 1로 한바퀴, 2로 한바퀴, 3으로 한바퀴 각각 dp를 돌려야 한다.

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

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));
        StringBuilder sb = new StringBuilder();

        int[] dp = new int[10_001];
        dp[0] = 1;
        for (int i = 1; i <= 3; i++) {
            for (int j = i; j < 10_001; j++) {
                dp[j] += dp[j - i];
            }
        }

        int T = Integer.parseInt(br.readLine());
        for (int t = 1; t <= T; t++) {
            int n = Integer.parseInt(br.readLine());
            sb.append(dp[n]).append('\n');
        }
        bw.write(sb.toString());
        bw.flush();
    }
}

코드 해석

dp배열을 최댓값인 10,000까지 먼저 채운다.
- dp[0] 만 초기값으로 1을 넣어준다.
- 1로 한바퀴, 2로 한바퀴, 3으로 한바퀴 dp 배열을 채워 중복을 피한다.

end

중복을 제거하는 방법을 많이 고민했던 것 같다.
생각보다 풀이 결과는 간단해서 이런 종류에 대한 연습이 부족했던 것 같다.

Lv.3 : 고고학 최고의 발견

Soom_1n — Thu, 15 Aug 2024 19:12:20 +0900

문제링크

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 분석

N*N 행렬에서 모든 칸의 숫자(시계)를 0(12시방향)으로 만들어야 한다.
- 0 : 12시, 1 : 3시, 2 : 6시, 3 : 9시
한 칸의 시계를 시계방향으로 돌릴 수 있고, 돌리면 상하좌우 인접한 시계도 함께 돌아간다.
모든 시계를 12시 방향으로 만드는 최소 조작 횟수를 출력한다.

문제 풀이

여러 경우의 수를 따져봐야 하는데, BruteForce는 O(64^4)이므로 너무 크다.
Greedy 접근으로 풀이할 수 있다.
- 시계를 조작하는 순서는 상관 없으므로 위쪽에서 아래쪽 행으로 조작하고자 한다.
- 첫 행의 상태만 임의로 정하면, 다음 행은 위쪽 행을 0으로 만들기 위해 돌리면 된다.
- 마지막 행까지 돌렸을 때 모두 0인 경우의 최소 조작 횟수를 구한다.
- 첫 행만 모든 경우의 수를 따져보면 되므로 O(8^4)로 줄어든다.

코드

class Solution {
    private final int[][] dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 상 우 하 좌
    private int n;
    
    public int solution(int[][] clockHands) {
        
        int min = Integer.MAX_VALUE;
        n = clockHands.length;
        
        // Greedy
        for(int i = 0; i < (1 << (2*n)); i++) { // 첫 행 모든 경우의 수
            int[][] copy = deepCopy(clockHands);
            int cnt = 0;
            int temp = i;
            
            // 첫 행 조작
            for(int col = 0; col < n; col++) { // 오른쪽 부터 0~3 으로 돌려보기
                int rotateCnt = temp % 4;
                temp /= 4;
                cnt += rotateCnt;
                rotate(copy, 0, col, rotateCnt);
            }
            
            // 나머지 행 조작
            for(int row = 1; row < n; row++) {
                for(int col = 0; col < n; col++) {
                    int rotateCnt = (4 - copy[row-1][col]) % 4; // 바로 윗행 값을 0으로 만드는 회전수
                    cnt += rotateCnt;
                    rotate(copy, row, col, rotateCnt);
                }
            }
            
            // 마지막 행이 모두 0인지 확인
            boolean flag = true;
            for(int col = 0; col < n; col++) {
                if(copy[n-1][col] != 0)  {
                    flag = false;
                    break;
                }
            }
            if(flag) min = Math.min(min, cnt);
        }

        return min;
    }
    
    private void rotate(int[][] arr, int row, int col, int rotateCnt) {
        arr[row][col] = (arr[row][col] + rotateCnt) % 4; // 현재 좌표 돌림
        for(int[] d : dir) {
            int r = row + d[0];
            int c = col + d[1];
            if( 0 <= r && r < n && 0 <= c && c < n) {
                arr[r][c] = (arr[r][c] + rotateCnt) % 4; // 4방 좌표 돌림
            }
        }
    }
    
    private int[][] deepCopy(int[][] arr) {
        int[][] copy = new int[n][n];
        for(int i = 0; i < n; i++) {
            System.arraycopy(arr[i], 0, copy[i], 0, n);
        }
        return copy;
    }
}

코드 해석

첫 행의 경우의 수는 n칸을 0~3 숫자로 채우는 것이다.
- 1부터 4^n까지 키워나가면 되는데, 1 << (2 * n)으로 4*n을 표현할 수 있다.
- 4 모듈러 연산으로 n 번째부터 0번째 칸을 채울 수 있다.
- 다음 칸을 채울 때는 4로 나눈 몫을 값으로 저장해 넘긴다.
첫 행의 각 경우의 수를 따져보기 위해 입력 받은 2차원 배열을 복사해야 한다.
- 깊은 복사를 수행하는 deepCopy() 메서드를 만들어서 사용했다.
한 시계를 돌렸을 때, 인접 시계도 돌아가야 하므로 rotate() 메서드를 만들어 사용했다.
첫 행을 제외한 나머지 행이 각각 위쪽 행의 값을 모두 0으로 만들도록 조작한다.
마지막 행까지 모두 0이 된 경우에서 조작 횟수의 최솟값을 기록한다.

end

상당히 어렵게 다가온 문제이다. 처음엔 문제 분석과 풀이 전략을 적어가며 시간을 보냈고, 그리디를 선택했지만 방법이 틀려서 테스트1, 테스트2를 제외하고 시간초과가 났었다.

/*
< 문제 정리 >
  - N*N 행렬에 시계들이 채워있음 (N : clockHands의 길이)
  - 시계는 상하좌우 4방향 (12시부터 시계방향 0,1,2,3)
  - 최소 조작으로 모든 방향이 0이 되도록 하기

< 풀이 계획 >
1) 알고리즘
    - DFS
        - 행렬의 상태 저장이 필요하므로 DFS 어떤가
        - 그럼 깊이의 최대는? -> 가늠할 수 없는 것 같으니 포기
    - 그리디**
        - 돌렸을 때 12시가 되는 바늘이 많으면 +1, 주변에 0 개수는 -1
    - BFS
        - 방문체크를 2차원 배열로?
        - 최대 64칸을 4가지 경우의수 : 4^64 = 너무큼
    - 역방향 탐색
        - 모두 12시 상태에서 기존 상태 만들기
        - 잘 모르겠음
    - 그리디 ---- 정답 풀이 2개맞고 나머지 시간초과 나서 풀이 봄
        - >> 조작 순서가 중요하지 않으므로 규칙을 정해 한 방향으로 조작하면 됨 <<
        - 위에 첫 행을 임의조작하고, 다음 행에서 윗 줄이 0이 되도록 조작
        - 마지막 행까지 완료했을 때 모두 0이 됐는지 확인
        - 첫 행의 경우의 수만 따지면 되므로, 브루트포스 4^64에서 -> 그리디 4^8로 줄어듦
        
2) 메서드
    - 일단 돌리는건 1회당 시계방향 1칸
    - 인접한 인덱스도 회전 하는 기능 필요
*/

결국 풀이 전략 힌트를 봤지만, 첫 행의 경우의 수를 어떻게 해야할 지 몰라서 정답 코드까지 보고 클론 코딩 하듯 풀이를 제출했다.
이 문제의 핵심 풀이 요소는 조작 순서가 상관 없으므로 한 방향으로 일정하게 돌리면 된다는 것이다.
- 위 풀이에서도 첫 행의 상태를 만들 때 n-1번부터 0번 인덱스 까지 값을 채워나가며 돌렸고,
  그 다음은 행을 1~n-1 까지 이동하며 값을 채워 나갔다.
첫 행의 상태를 만들때 비트 연산과 모듈러 연산을 기가막히게 사용한걸 보고 감탄했다.
여러모로 배운게 많은 문제였던 것 같다.