느려도 착실하게 나아가기

Good Bye, BOJ!

로띠마이 — Sun, 26 Apr 2026 17:44:50 +0900

정들었던 Boj가 서비스 종료한다고 해서 마지막 날 기록

대학 생활 그래도 유일하게 공부(?) 비슷하게 꾸준히 했었던 게 백준 알고리즘 문제 풀기인데 너무 아쉽다.

아직 코테를 완전히 뚫을 정도로 실력이 좋지는 못하지만, 그래도 어느정도 기본기는 백준 덕분에 갖췄다고 해도 무방한듯 하다.

고마웠어!

[백준/java] 15684번 - 사다리 조작

로띠마이 — Wed, 4 Feb 2026 01:48:45 +0900

[ 문제 ]

https://www.acmicpc.net/problem/15684

간단하게 설명하면 일반적인 사다리게임에서 추가적으로 최대 3개의 선을 추가하여 모든 i번 세로선들의 결과가 i로 나오게 만드는 최소 가로선 추가 개수를 출력하는 문제이다.

[ 구현 ]

적용시킨 알고리즘은 백트래킹(Backtracking) 기반 DFS로 조합을 탐색하는 완전탐색(Brute Force)

우선 주어진 가로선들의 입력을 받았을 때

map[a][b] = 1; // 오
map[a][b + 1] = -1; // 왼

와 같은 방식으로 사다리를 구현해주었다.

map[a][b] = 1만 해두고, 조건 검사시에 map[a][b - 1] ==1 인지 함께 검사해주는 방식으로 구현해도 무방할 듯 하였지만, 뭔가 이 방식이 더 깔끔해보여서 고민끝에 이렇게 구현했다.

--------------

private static void dfs(int r, int c, int cnt) {
    if (check()) {
        ans = Math.min(ans, cnt);
        return;
    }

    else if (cnt == 3) {
        return;
    }

    for (int i = r; i <= h; i++) {
        int start = (i == r ? c : 1); // 이전 위치와 다른 행이면 열 위치 1부터 탐색
        for (int j = start; j <= n - 1; j++) {
            if (isAvailableLine(i, j)) {
                map[i][j] = 1;
                map[i][j + 1] = -1;
                // 같은 행이면 j+2부터(인접 불가), 다음 행으로 넘어가면 1부터
                dfs(i, j + 2, cnt + 1);
                map[i][j] = 0;
                map[i][j + 1] = 0;
            }
        }
    }
}

그리고 dfs를 통해 가능한 가로선들을 조합, 이후 현재 상태에서 모든 세로선들이 자신의 위치로 내려올 수 있는지 판단해주었다.

보통의 backtracking 문제들은 cnt == 3와 같은 종료 조건 도달시점에 최적의 해를 갱신하는데,

이 문제의 경우 더 적은 가로선을 가지고도 충분히 최종 조건을 만족할 수 있으므로 그 부분까지 신경써서 해를 갱신해주었다.

가로선을 조합할 때, 이전에 뽑은 위치와 인접한 경우는 불가능하므로 j + 2를 통해 해당 위치를 건너뛰었고,

만일 해당 열의 끝에 도달해 다음 행을 고려해야하는 경우 다시 1열부터 후보군을 선정해야하기 때문에 해당 부분을

start = (i == r ? c : 1)와 같은 형식으로 처리해주었다.

private static boolean isAvailableLine(int r, int c) {
    if (map[r][c + 1] == 1) return false;
    else if (map[r][c] == 1) return false;
    else if (map[r][c - 1] == 1) return false;
    return true;
}

가능한 가로선인지 판별하는 로직은

1. 현재 위치에 가로선이 있는지

2. 현재 위치에서 열 + 1의 위치에 가로선이 있는지

3. 현재 위치에서 열 - 1의 위치에 가로선이 있는지

를 판단해주었고, 이때 map[a][0]의 위치는 어차피 값이 0으로 초기화되어있고 갱신되지 않으므로 고려해주지 않아도 되었다.

가로선을 뽑아놓고 모든 세로선들이 최종적으로 자기 위치에 도착하는지를 확인하는 로직은 직관적이므로 생략하겠다.

[ 코드 ]

package p_15684;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    static int n, m, h;
    static int[][] map;
    static int ans = 4;

    static class Reader {
        BufferedReader br;
        StringTokenizer st;

        Reader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void readInput() {
        Reader reader = new Reader();
        n = reader.nextInt();
        m = reader.nextInt();
        h = reader.nextInt();

        map = new int[h + 1][n + 1];

        for (int i = 0; i < m; i++) {
            int a = reader.nextInt();
            int b = reader.nextInt();

            map[a][b] = 1; // 오
            map[a][b + 1] = -1; // 왼
        }
    }

    private static void dfs(int r, int c, int cnt) {
        if (check()) {
            ans = Math.min(ans, cnt);
            return;
        }

        else if (cnt == 3) {
            return;
        }

        for (int i = r; i <= h; i++) {
            int start = (i == r ? c : 1); // 이전 위치와 다른 행이면 열 위치 1부터 탐색
            for (int j = start; j <= n - 1; j++) {
                if (isAvailableLine(i, j)) {
                    map[i][j] = 1;
                    map[i][j + 1] = -1;
                    // 같은 행이면 j+2부터(인접 불가), 다음 행으로 넘어가면 1부터
                    dfs(i, j + 2, cnt + 1);
                    map[i][j] = 0;
                    map[i][j + 1] = 0;
                }
            }
        }
    }

    private static boolean isAvailableLine(int r, int c) {
        if (map[r][c + 1] == 1) return false;
        else if (map[r][c] == 1) return false;
        else if (map[r][c - 1] == 1) return false;
        return true;
    }

    private static boolean check() {
        for (int i = 1; i <= n; i++) {
            if (!checkLine(i)) return false;
        }
        return true;
    }

    private static boolean checkLine(int idx) {
        int pos = idx;
        for (int i = 1; i <= h; i++) {
            if (map[i][pos] == 1) pos++;
            else if (map[i][pos] == -1) pos--;
        }
        if (pos == idx) return true;
        else return false;
    }

    private static void printAnswer() {
        if (ans == 4) System.out.println(-1);
        else System.out.println(ans);
    }

    private static void solution() {
        readInput();
        dfs(1, 1, 0);
        printAnswer();
    }

    public static void main(String[] args) {
        Main.solution();
    }
}

[ 마무리 및 느낀 점 ]

요즘은 삼성 SW 역량 기출 문제들을 풀어보고 있다.

솔직히 문제 하나하나 구현이 복잡하긴 하지만, 좋은 문제들이라는 느낌을 받았다.

안 풀어본 문제들을 전부 풀어봐야겠다.

[백준/java] 11779번 - 최소비용 구하기 2

로띠마이 — Fri, 7 Nov 2025 00:01:37 +0900

[ 문제 ]

[ 구현 ]

다익스트라를 적용해서 풀되, 경로 추적을 위한 parent 배열을 하나 따로 관리해주면 되는 문제이다.

경로 복원을 할 때는 목표 지점에서부터 반대로 탐색하게 되므로 Stack(Deque)을 통해 뒤집어서 출력해주면 된다.

[ 코드 ]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static final int INF = Integer.MAX_VALUE;
    static int n, m;
    static int goalS, goalE;
    static List<List<Node>> graph = new ArrayList<>();
    static int[] dist;
    static int[] parent;

    static class Node implements Comparable<Node>{
        int idx;
        int cost;

        Node(int idx, int cost) {
            this.idx = idx;
            this.cost = cost;
        }

        @Override
        public int compareTo(Node o) {
            return Integer.compare(this.cost, o.cost);
        }
    }

    private static void readInput() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());
        m = Integer.parseInt(br.readLine());

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

        dist = new int[n + 1];
        parent = new int[n + 1];

        for (int i = 0; i <= n; i++) {
            dist[i] = INF;
            parent[i] = -1;
        }

        for (int i = 0; i < m; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());

            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            int cost = Integer.parseInt(st.nextToken());

            graph.get(a).add(new Node(b, cost));
        }

        StringTokenizer st = new StringTokenizer(br.readLine());

        goalS = Integer.parseInt(st.nextToken());
        goalE = Integer.parseInt(st.nextToken());

        br.close();
    }

    private static void dijkstra(int start) {
        PriorityQueue<Node> pq = new PriorityQueue<>();

        pq.offer(new Node(start, 0));
        dist[start] = 0;

        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int curIdx = node.idx;
            int costSum = node.cost;

            if (dist[curIdx] < costSum) continue;

            for (Node adjNode : graph.get(curIdx)) {
                int adjIdx = adjNode.idx;
                int cost = adjNode.cost;

                if (dist[adjIdx] > dist[curIdx] + cost) {
                    dist[adjIdx] = dist[curIdx] + cost;
                    parent[adjIdx] = curIdx;
                    pq.add(new Node(adjIdx, dist[adjIdx]));
                }
            }
        }
    }

    private static void calculatePath() {
        StringBuilder sb = new StringBuilder();

        sb.append(dist[goalE]);
        sb.append("\n");

        Deque<Integer> st = new ArrayDeque<>();

        int cur = goalE;

        while (cur != -1) {
            st.push(cur);
            cur = parent[cur];
        }

        sb.append(st.size());
        sb.append("\n");

        while (!st.isEmpty()) {
            int idx = st.pop();
            sb.append(idx);
            sb.append(" ");
        }

        sb.deleteCharAt(sb.length() - 1);

        System.out.println(sb);
    }

    private static void solution() throws IOException {
        readInput();
        dijkstra(goalS);
        calculatePath();
    }

    public static void main(String[] args) throws IOException{
        Main.solution();
    }
}

[ 마무리 및 느낀 점 ]

다익스트라를 안 보고 구현이 가능하게 되었다.

까먹지 좀 말자.. ㅋㅋ

[백준/java] 25515번 - 트리 노드 합의 최댓값

로띠마이 — Thu, 30 Oct 2025 16:24:43 +0900

[ 문제 ]

[ 구현 ]

최근 트리 dp 문제들을 풀어보기 시작했다.

기본적으로 트리가 모든 노드들이 연결된 사이클 없는 그래프이므로
루트에서부터 dfs를 통해 탐색하되, 해당 서브트리를 기준으로 해당 시점에 최적이라고 생각되는 부분을 기록해서 전체를 이룬다.

이 문제의 경우 전체 노드들을 선택적으로 방문하여더해서 최대를 만들어야 했으므로

해당 서브트리에 속한 노드들의 최대 합이 음수인 경우는 최적의 해 구성에서 제외하도록 신경써주는 것이 포인트였다.

dp[idx] = Math.max(dp[idx], dp[idx] + dp[adjIdx]);
이 부분에서 현재 노드를 루트로하는 서브트리의 노드들의 합을 구성할 때, 자식을 루트로 하는 서브트리의 노드들의 합이 어떻게 해도 음수인 경우 최적의 해 구성에서 제외하는 것을 알 수 있다.

[ 코드 ]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static int n;
    static List<List<Integer>> tree = new ArrayList<>();
    static int[] score;     // 각 노드에 적힌 정수
    static long[] dp;    // 해당 인덱스 노드를 루트로 한 서브트리의 정수 합 최댓값
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;

    private static void readInput() throws IOException {
        n = Integer.parseInt(br.readLine());

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

        score = new int[n];
        dp = new long[n];

        int p,c;

        for (int i = 0; i < n - 1; i++) {
            st = new StringTokenizer(br.readLine());
            p = Integer.parseInt(st.nextToken());
            c = Integer.parseInt(st.nextToken());

            tree.get(p).add(c);
            tree.get(c).add(p);
        }

        st = new StringTokenizer(br.readLine());

        int x = 0;
        while(st.hasMoreTokens()) {
            score[x] = Integer.parseInt(st.nextToken());
            x++;
        }
    }

    private static void dfs(int idx, int prev) {
        if (dp[idx] != 0) return;

        dp[idx] = score[idx];

        for (int adjIdx : tree.get(idx)) {
            if (prev != adjIdx) {   // 부모 노드를 다시 방문하는 경우를 방지
                dfs(adjIdx, idx);
                dp[idx] = Math.max(dp[idx], dp[idx] + dp[adjIdx]);  // 하위 서브트리 정점들의 합이 음수인 경우 포함하지 않아야 함
            }
        }
    }

    private static void printAnswer() {
        StringBuilder sb = new StringBuilder();
        sb.append(dp[0]);
        System.out.println(sb.toString());
    }

    private static void solution() throws IOException {
        readInput();
        dfs(0, -1); // 루트의 부모는 없으므로 -1
        printAnswer();
    }

    public static void main(String[] args) throws IOException {
        Main.solution();
    }
}

[ 마무리 및 느낀 점 ]

좀 더 심화된 트리 dp문제를 풀어보며 맛을 봐야겠다.

[백준/java] 14499번 - 주사위 굴리기

로띠마이 — Fri, 26 Sep 2025 02:15:10 +0900

[ 문제 ]

[ 구현 ]

주사위의 형태를 어떻게 관리하고
동서남북 이동에 따라 어떤 식으로 위치가 변화하는지만 관리해주면 되는 문제지만 좀 번거로웠다.

0(윗면), 1(바닥면), 2(북쪽면), 3(남쪽면), 4(동쪽면), 5(서쪽면)으로 주사위 배열의 인덱스를 잡아두고

입력에 따라 동서남북으로 이동했을 시 어떻게 해당 주사위의 면이 옮겨가는지를 일일이 생각해주었다.

ex) 동쪽으로 이동할 경우 : 윗면 -> 동쪽면, 동쪽면 -> 바닥면, 바닥면 -> 서쪽면, 서쪽면 -> 윗면

정리한 이동 로직에 따라 범위가 벗어나지 않는지 체크하고 괜찮다면 해당 위치로 이동 +

이동한 후의 주사위 윗면을 출력해주면 된다.

[ 코드 ]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static int n, m, x, y, k;
    static int[][] map;
    static List<Integer> command = new ArrayList<>();
    static int[] dice = new int[6]; // 0(윗면), 1(바닥면), 2(북쪽면), 3(남쪽면), 4(동쪽면), 5(서쪽면)
    static int[] dx = {0, 0, 0, -1, 1};
    static int[] dy = {0, 1, -1, 0, 0};
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;

    private static void readInput() throws IOException {
        st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        x = Integer.parseInt(st.nextToken());
        y = Integer.parseInt(st.nextToken());
        k = 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());
            }
        }

        st = new StringTokenizer(br.readLine());
        while (st.hasMoreTokens()) {
            command.add(Integer.parseInt(st.nextToken()));
        }
    }

    private static void rollEast(int[] arr) {
        int t = arr[0], b = arr[1], n = arr[2], s = arr[3], e = arr[4], w = arr[5];
        // 윗면 -> 동쪽면, 동쪽면 -> 바닥면, 바닥면 -> 서쪽면, 서쪽면 -> 윗면
        arr[4] = t;
        arr[1] = e;
        arr[5] = b;
        arr[0] = w;
    }

    private static void rollWest(int[] arr) {
        int t = arr[0], b = arr[1], n = arr[2], s = arr[3], e = arr[4], w = arr[5];
        // 윗면 -> 서쪽면, 서쪽면 -> 바닥면, 바닥면 -> 동쪽면, 동쪽면 -> 윗면
        arr[5] = t;
        arr[1] = w;
        arr[4] = b;
        arr[0] = e;
    }

    private static void rollNorth(int[] arr) {
        int t = arr[0], b = arr[1], n = arr[2], s = arr[3], e = arr[4], w = arr[5];
        // 윗면 -> 북쪽면, 북쪽면 -> 바닥면, 바닥면 -> 남쪽면, 남쪽면 -> 윗면
        arr[2] = t;
        arr[1] = n;
        arr[3] = b;
        arr[0] = s;
    }

    private static void rollSouth(int[] arr) {
        int t = arr[0], b = arr[1], n = arr[2], s = arr[3], e = arr[4], w = arr[5];
        // 윗면 -> 남쪽면, 남쪽면 -> 바닥면, 바닥면 -> 북쪽면, 북쪽면 -> 윗면
        arr[3] = t;
        arr[1] = s;
        arr[2] = b;
        arr[0] = n;
    }

    private static void copy(int a, int b) {
        if (map[a][b] == 0) {
            map[a][b] = dice[1];
        }

        else {
            dice[1] = map[a][b];
            map[a][b] = 0;
        }
    }

    private static void roll(int command) {
        int nx = x + dx[command];
        int ny = y + dy[command];

        if (nx < 0 || ny < 0 || nx >= n || ny >= m) return;

        switch (command) {
            case 1:
                rollEast(dice);
                copy(nx, ny);
                break;
            case 2:
                rollWest(dice);
                copy(nx, ny);
                break;
            case 3:
                rollNorth(dice);
                copy(nx, ny);
                break;
            case 4:
                rollSouth(dice);
                copy(nx, ny);
                break;

        }

        x = nx;
        y = ny;

        System.out.println(dice[0]);
    }

    private static void solution() throws IOException {
        readInput();
        for (int cmd : command) {
            roll(cmd);
        }
    }

    public static void main(String[] args) throws IOException {
        Main.solution();
    }
}

[ 마무리 및 느낀 점 ]

문제 자체가 어렵다기보다는 실전에서 얼마나 빠르고 정확하게 풀어낼 수 있는지가 관건인듯 하다.

[백준/java] 1757번 - 달려달려

로띠마이 — Thu, 28 Aug 2025 17:41:41 +0900

[ 문제 ]

[ 구현 ]

잘 모르겠어서 gpt한테 힌트달라고 했는데도 점화식 이해하는데 좀 애먹었다..

힌트보고 이해한 다음에 코드는 손수 짰는데, 배열 크기 관련해서 신경써줘야하는 부분이 좀 있어서 디버깅하면서 고쳤다.

dp[i] = 시각 i부터 N까지 시작할 때 얻을 수 있는 최대 거리 (이때 지침 지수는 0)로 잡고

누적합을 통해 필요한 구간의 합을 계산하였다.

이때 필요한 구간의 합이란 연속으로 달릴 구간을 의미한다(i ~ i + L - 1)

dp자체가 bottom-up 방식이 아니라 top-down 방식으로 내려가는 형식이며

L이 가지는 제한 조건 -> L <= (n - i + 1) / 2를 반영해주면 된다.(끝날때 지침 지수가 0이려면 구간의 절반을 넘게 달릴 순 없음)

최종적으로 핵심이 되는 점화식은

dp[i] = Math.max(dp[i+1], sum(i ~ i + L - 1) + dp[i+2L])이다.

우선 dp[i+1]은 이전까지 구했던 값이 더 큰 경우 현상유지를 위한 기본 코드이며

i부터 시작해서 L만큼 달렸을때의 거리를 누적합을 통해 O(1)을 통해 계산하였다.

추가적으로 2L의 의미는 L 구간만큼 연속으로 달리면 다시 L구간만큼 쉬어줘야하기 때문에 그 부분이 반영되었다.

다만 L값이 증가함에 따라 값이 바뀌는 부분도 기록을 해줘야하기 때문에 Math.max(dp[i], ...)를 한번 더 감싸주었다.

+) 또한 dp[i + 2 * j]에서 인덱스가 n + 1까지 도달하는 경우 발생하기 때문에 arrayIndexOutOfBoundError가 터질 수 있어, 크기를 의도적으로 n + 2로 잡아주었다.

[ 코드 ]

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

// dp[i] = 시각 i부터 N까지 시작할 때 얻을 수 있는 최대 거리 (이때 지침 지수는 0)
public class Main {

    static int[] dp;
    static int n, m;
    static int[] dist;
    static int[] prefixDist;
    static int answer;
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    private static void readInput() throws IOException{
        String input = br.readLine();
        String[] arr = input.split(" ");
        n = Integer.parseInt(arr[0]);
        m = Integer.parseInt(arr[1]);

        dist = new int[n + 2];
        prefixDist = new int[n + 1];
        dp = new int[n + 2];
        
        for (int i = 1; i <= n; i++) {
            input = br.readLine();
            dist[i] = Integer.parseInt(input);
            prefixDist[i] = prefixDist[i - 1] + dist[i];
        }
    }

    private static void dp() {
        for (int i = n - 1; i >= 1; i--) {
            for (int j = 1; j <= (n - i + 1) / 2; j++) {
                // i부터 L거리만큼 연속으로 달린 경우 거리 계산(누적합 배열을 이용해 N(1)으로)
                int distSum = prefixDist[n] - prefixDist[i - 1] - (prefixDist[n] - prefixDist[i + j - 1]);
                dp[i] = Math.max(dp[i], Math.max(dp[i + 1], distSum + dp[i + 2 * j]));
            }
        }

        answer = dp[1];
    }

    private static void solution() throws IOException {
        readInput();
        dp();
        System.out.println(answer);
    }

    public static void main(String[] args) throws IOException {
        Main.solution();
    }
}

[ 마무리 및 느낀 점 ]

개인적으로 골드4이지만 간단히 풀기는 어려운 느낌의 dp인 것 같다.

dp 관련해서 좀 더 공부를 하고 다양한 케이스를 접하며 기본 이해도를 높여야겠다.

같은 문제를 2차원 dp, 3차원 dp로 풀 수 있는 것 같던데 한번 시도해볼 예정이다.

[백준/java] 14502번 - 연구소

로띠마이 — Sun, 17 Aug 2025 14:24:47 +0900

[ 문제 ]

[ 구현 ]

벽을 3군데 세우는 부분은 dfs + backtracking으로 처리하고,벽이 세워진 이후에 bfs로 넘어가서 바이러스가 퍼트려지도록 시뮬레이션을 돌리고 안전한 구역의 최대를 저장해두는 식으로 풀었다.

[ 코드 ]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static int n, m;
    static int[][] map;
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int[] dx = {-1, 0, 0, 1};
    static int[] dy = {0, -1, 1, 0};
    static int answer = 0;

    private static class Node {
        int x, y;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    private static void readInput() throws IOException {
        st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = 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());
            }
        }
    }

    private static int calSafe(int[][] arr) {
        int cnt = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (arr[i][j] == 0) {
                    cnt++;
                }
            }
        }

        return cnt;
    }

    private static void bfs() {
        Queue<Node> q = new LinkedList<>();

        int[][] map_copy = new int[n][m];

        for (int i = 0; i < n; i++) {
            map_copy[i] = map[i].clone();
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (map_copy[i][j] == 2) {
                    q.offer(new Node(i, j));
                }
            }
        }

        while (!q.isEmpty()) {
            Node cur = q.poll();

            for (int i = 0; i < 4; i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
                else if (map_copy[nx][ny] == 1 || map_copy[nx][ny] == 2) continue;
                else {
                    map_copy[nx][ny] = 2;
                    q.offer(new Node(nx, ny));
                }
            }
        }

        answer = Math.max(answer, calSafe(map_copy));
    }

    private static void dfs(int depth) {
        if (depth == 3) {
            bfs();
            return;
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (map[i][j] == 0) {
                    map[i][j] = 1;
                    dfs(depth + 1);
                    map[i][j] = 0;
                }
            }
        }
    }

    private static void solution() throws IOException {
        readInput();
        dfs(0);
        System.out.println(answer);
    }

    public static void main(String[] args) throws IOException{
        solution();
    }
}

[ 마무리 및 느낀 점 ]

전체적으로 풀어야할 흐름자체는 직관적인 편이라 풀이과정을 떠올리는데 어렵지는 않았다.단지 아직 dfs + backtracking 부분에서 좀 자신이 없는 듯하여 관련 부분을 따로 연습하는 것이 좋아보인다.좀 더 사고력을 요하는 골드3 이상의 문제를 풀기 시작해야겠다.

[백준/java] 2539번 - 모자이크

로띠마이 — Thu, 14 Aug 2025 19:58:03 +0900

[ 문제 ]

[ 구현 ]

가능한 색종이의 최소 크기를 구해야하는 것이므로 이분탐색 + 그리디 느낌으로 푸는 문제

색종이를 반드시 도화지의 밑변에 맞추어 붙이는 것이므로,

앞에서부터 색종이를 붙여나가면서 주어진 색종이의 개수로 전체 잘못된 영역을 커버할 수 있는지 확인하고

이분탐색을 통해 색종이의 개수를 늘리거나 줄인다.

색종이를 밑바닥부터 댔을 때, 높이가 부족한 경우 불가능하므로 바로 false를 리턴

최소 색종이 크기를 물어봤으므로 lower_bound에 해당하고

따라서 min(left)의 값이 최종적으로 정답이 된다.

[ 코드 ]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int r, c, n; // 행, 열, 사용 가능한 색종이 개수
    static int min, max;
    static int wrongCount;  // 입력 받아야하는 잘못된 위치 개수
    static List<Node> list = new ArrayList<>();

    private static class Node implements Comparable<Node> {
        int row;
        int col;

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

        @Override
        public int compareTo(Node n) {
            return this.col - n.col;
        }
    }

    private static void readInput() throws IOException {
        st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());

        n = Integer.parseInt(br.readLine());

        wrongCount = Integer.parseInt(br.readLine());

        for (int i = 0; i < wrongCount; i++) {
            st = new StringTokenizer(br.readLine());
            int row = Integer.parseInt(st.nextToken());
            int col = Integer.parseInt(st.nextToken());

            list.add(new Node(row, col));
            max = Math.max(max, Math.max(row, col));    // 행, 열 길이 중 큰 것을 최대로 기록
        }

        Collections.sort(list);
    }

    // 해당 색종이 크기로 모두 가릴 수 있는지 확인
    private static boolean checkSize(int size) {
        int cnt = 0;
        int col_pos = 0; // 이전까지 가린 마지막 열 위치

        for (int i = 0; i < list.size(); i++) {
            Node cur = list.get(i);

            if (size < cur.row) return false; // 바닥에서부터 가려도 높이가 부족한 경우

            else if (col_pos == 0 || col_pos < cur.col) { // 새로운 색종이로 가려야 하는 경우
                col_pos = cur.col + size - 1; // 마지막으로 커버한 위치가 아니라, 이번에 가리기 시작할 위치부터 더해야 함!
                cnt++;

                if (cnt > n) return false;
            }
        }

        return true;
    }

    private static int binarySearch() {
        min = 1;

        while (min <= max) {
            int mid = (min + max) / 2;

            if (checkSize(mid)) max = mid - 1; // 가능한 경우, 색종이 크기를 줄여서 시도
            else min = mid + 1; // 불가능한 경우, 색종이 크기를 늘려서 시도
        }

        return min;
    }

    public static void solution() throws IOException {
        readInput();
        int ans = binarySearch();
        System.out.println(ans);
    }

    public static void main(String[] args) throws IOException {
        solution();
    }
}

[ 마무리 및 느낀 점 ]

최근에 Java로 코테를 준비하기 시작했는데 c++에 비해 외워야 할 메소드나 형식이 많아서 좀 더 많은 주의가 필요할 듯 하다.

백엔드 부트캠프 한화시스템 BEYOND SW 캠프 15기 수료 후기

로띠마이 — Sun, 27 Jul 2025 01:33:21 +0900

1월 21일부터 7월 21일까지 6개월간의 긴 여정동안 나름대로 성실하게 임하면서 잘 마무리할 수 있었던 것 같다.

초기에 마음먹었던대로 갓생(?)을 살지는 못하였지만,

6개월이라는 긴 시간동안 휴가도 한번쓰지 않고 결석이나 지각 없이 잘 마무리한 것만으로도 자신을 칭찬해주고 싶다.

짧지 않은 시간이었던만큼 나름대로 여러가지 면에서 성장할 수 있었다.

[커리큘럼]

기반기술
- Git, 소프트웨어공학, DB, Linux
백엔드
- Java
- 알고리즘
- SpringBoot
- Spring Cloud(Eureka Service Discovery, Api Gateway, Config Server...)
프론트엔드
- html, css, javascript 기초 + Vue.js
데브옵스
- Message Broker & Logging & Monitoring 정말 가볍게
- Docker
- Kubernetes
- CI/CD(Jenkins)

가장 시간을 많이 들여가며 배웠던 파트는 DB와 SpringBoot 부분이었다.

DB에서 학부시절에는 배우지 않았었던 Stored Procedure & Function과 같은 기능을 접해볼 수 있는 기회가 되었고,

이에 추가적으로 스터디를 진행하며 SQLD 자격증도 취득하였다.

Java의 경우 맘먹지 않으면 제대로 공부하기 힘든 Lambda와 그 기반이 되는 함수형 인터페이스에 대해 배우기도 했었고,

Stream의 정말 다양한 문법에 대해 그래도 한번 정리하는 시간도 가질 수 있어서 좋았다.

SpringBoot는 뭐 당연하게도 제일 핵심이 되는 백엔드 기술이니만큼 대부분 다룰만한 전반적인 내용들을 다뤘다.

특히 JDBC와 Servlet과 같은 상대적으로 추상화가 덜된 계층에 대해서도 학습하기도 했으며,

AOP나 Reflection와 같은 살짝 어려운 부분도 건드리고 JPA, MyBatis, Spring Security 등에 대해 배웠다.

MyBatis를 써볼 기회는 잘 없었는데, 확실히 필요에 따라서는 JPA보다 편리한 부분이 많아서 앞으로도 같이 혼용하지 않을까 생각중이다.

[팀 프로젝트]

위에 서술한 커리큘럼에 파이널 프로젝트까지 더해져서 총 5번의 프로젝트를 진행했다

첫번째 기반기술 프로젝트는

실제로 코딩에 가까운 작업은 이루어지지 않고, 기획 + 프로젝트 산출물과 DB(DDL + SQL문)에 집중했던 프로젝트였다.

그나마 특색있었던 부분은 Linux 기반 Ubuntu에서 MariaDB를 Master-Slave 구조로 직접 Replication 구축하는 부분이 있었다.

두번째는 백엔드 프로젝트로

막 배운 기본적인 SpringBoot를 통해 REST API를 구축하는 것에 집중하는 것에 더해

Spring Security나 Spring Cloud와 같은 디테일들을 챙겨가며 나름대로 서버간 통신하는 마이크로서비스 형태로 완성시키는 것에 의의를 두었다.

세번째는 프론트엔드 프로젝트였는데, 바로 이전에 진행했던 백엔드 프로젝트에 연동될 수 있는 페이지를 만들었다.

개인적으로는 이때가 좀 어려웠다.

처음 배우는 html, css, javascript, vue.js를 기반으로

css 디자인을 어떻게 잡고 또 어떻게 Vue.js를 통해 컴포넌트 해야할지에 대해서도 조금이나마 맨땅에 헤딩하며 감을 잡아가는 시간이었다.

추가적으로 Refresh Token을 위한 HttpOnly cookie나 local storage등의 개념, axios interceptor에 대해서도 가볍게 다루고 넘어가는게 도움이 된 것 같다.

네번째로는 데브옵스 프로젝트였고,

컨테이너 기반 가상화 기술인 Docker -> Docker compose -> Kubernetes의 흐름으로 넘어가며 배웠던 개념들을 하나하나 적용하고, 거기에 ElasticSearch, LogStash, Kibana 스택까지 추가로 얹는 느낌으로 진행했다.

실제로 배포까지는 이어지지 않았고 로컬 기반의 서버와 클라이언트 코드를 서로 실행시켜서 동작시키는 수준으로 마무리했다.

마지막으로 파이널 프로젝트는 여태까지 배웠던 모든 내용들에 얹어 각자 자신들의 기획에 맞는 추가적인 기술 적용을 하였으며,

입사 이후 이탈자를 방지할 수 있는 HR 사내 시스템을 구축했다.

결재, 근태, 알림, 공지, 평가, 근속 지원, 사원 관리, 챗봇 등 개발해야할 기능이 정말 많았고

나는 이중에서 공지, 알림, 챗봇에 더해 전반적인 배포를 전담했다.

이 과정에서 Message Broker(Kafka, Redis Pub/Sub), SSE, CloudFront SignedUrl + S3 PresignedUrl, LLM + RAG, AWS EKS등 정말 다양한 시도를 하였고 많은 것을 얻어갈 수 있었다.

기간이 길게 주어진 만큼 고민도 많이했고, 얻어가는 것도 가장 많았던 프로젝트였다.

추가적으로 한화시스템과 연계하여 진행되는 부트캠프인만큼 관련 현직 멘토분께서도 기획적인 부분을 많이 도와주셨고,

마지막에 평가는 실제로 차장급 2분이 와서 발표를 듣고 이루어졌다.

솔직하게 기술적인 부분에 대해서는 제대로 평가하기가 힘든 구석이 있는 것 같고(시간적으로 발표시간이 23분 정도로 촉박)

따라서 결국 기획의 참신함 + 유용함 + 전체적인 구현의 일관성 및 완성도로 당락이 결정되는 것 같다.

우리 조는 5명으로 1명 적은 인원이었음에도 불구하고, 정말 성실하고 열정적인 분들과 함께하여 좋은 결과물을 완성할 수 있었고 5개의 조 중에서 1위를 차지할 수 있었다.

[마무리하며]

6개월 동안 9 to 6로 동작의 캠퍼스에 매일 출석하여 강의를 듣고 프로젝트를 하는식으로 진행되다보니 정말 피곤한 경우도 많았다.

나는 그나마 집이 여의도로 가까운 편이라서 괜찮았지만, 통학시간이 1시간 30분 정도 걸리는 분들도 꽤 있었어서

그런분들은 보면서 조금 안쓰러울 정도였다.

그래도 같은 목표를 향해 걸어나가는 열정있는 수강생분들과 함께였기 때문에 놓지 않고 끝까지 버틸 수 있었다.

특히나 이번 기수는 강사님께서 말씀하시길 실력이 좋은 분들이 많은 편이라서, 서로 더 좋은 자극을 주고받으며 성장할 수 있었던 것 같다.

이제부터 본격적으로 취업 준비에 들어갈 듯 한데, 나 뿐만 아니라 함께했던 분들 모두 좋은 결과가 있기를 바라면서 마친다.

약 6개월간 함께 했던 출입증

프로젝트 1위 상장

화이트보드에 그려져있던 그림(항상 보면서 웃기지만 너무 공감됐던)

한화시스템 Beyond SW캠프 15기 10주차 회고

로띠마이 — Mon, 31 Mar 2025 23:30:23 +0900

뭔가 갈수록 마음의 여유가 없어지고 있는 것 같다.. ㅋㅋ

이번에는 SpringBoot(Exception Handler, Interceptor, Interceptor), Mybatis, JPA(영속성 컨택스트, 일반적인 Entity 매핑)에 대해 학습했다.

회고에 일일이 내용을 정리하기에는 너무 많기도 하고, 대부분 이해를 바탕으로 그냥 사용을 하면 되는 내용이기에 생략하고,

트랜잭션 격리 수준, 영속성 컨택스트 2가지는 가볍게 정리해보려고 한다.

[트랜잭션 격리수준]

READ UNCOMMITTED (가장 낮은 수준)
- 정의: 다른 트랜잭션이 커밋되지 않은 데이터를 읽을 수 있음
- 문제: Dirty Read 발생 가능 (다른 트랜잭션이 커밋하지 않은 데이터를 읽음)
- 예시: 트랜잭션 A가 값을 수정 중일 때, 트랜잭션 B는 그 값을 읽을 수 있음
READ COMMITTED
- 정의: 트랜잭션은 커밋된 데이터만 읽을 수 있음
- 문제: Non-repeatable Read 발생 가능 (한 트랜잭션 내에서 읽은 값이 다른 트랜잭션에 의해 수정될 수 있음)
- 예시: 트랜잭션 A가 값을 읽고, 트랜잭션 B가 값을 수정한 후, 트랜잭션 A가 다시 그 값을 읽을 때 다른 값이 나올 수 있음
REPEATABLE READ
- 정의: 트랜잭션이 처음 읽은 데이터를 다른 트랜잭션에서 수정하지 못하도록 함
- 문제: Phantom Read 발생 가능 (다른 트랜잭션이 새로운 데이터를 삽입할 수 있음)
- 예시: 트랜잭션 A가 읽은 데이터는 다른 트랜잭션이 수정할 수 없지만, 새로운 데이터가 추가될 수 있음
SERIALIZABLE (가장 높은 수준)
- 정의: 트랜잭션이 완전하게 직렬화되어 실행되는 수준
- 문제: 성능 저하 (동시성은 낮고, 순차적으로 실행됨)
- 예시: 트랜잭션 A가 데이터를 읽고 수정할 때, 다른 트랜잭션은 해당 데이터를 수정하거나 삽입할 수 없음

[영속성 컨택스트]

-엔티티 매니저가 생성될 때 하나의 영속성 컨택스트가 만들어짐

-영속성 컨택스트는 엔티티를 1차 캐시에 저장, 동일한 엔티티를 두 번 조회하지 않도록 함.

find()

영속성 컨텍스트에 존재하는 경우: DB에서 조회하지 않고, 1차 캐시에서 엔티티를 반환.
영속성 컨텍스트에 존재하지 않는 경우: DB에서 즉시 조회하여 해당 엔티티를 영속성 컨텍스트에 저장.

persist()

새로운 엔티티가 영속성 컨텍스트에 추가되고, DB에 즉시 반영되지 않음.
트랜잭션이 커밋될 때 영속성 컨텍스트에 있는 모든 변경사항이 쓰기 지연 방식으로 DB에 반영

merge()

기존 엔티티 또는 분리된(detached) 엔티티를 영속성 컨텍스트로 병합(merge)하는 데 사용

[마무리하며]

최근 수업진도가 꽤 빨라서, 솔직히 수업내용을 온전히 100퍼센트 소화하진 못한 것 같다. 그래도 전반적인 흐름은 파악했으니, 필요할 때 다시 그 부분을 들쳐내서 공부하면 되지 않을까라고 생각하고 있다. 프로젝트 개발하면서 좀 더 체화시켜보자..

SQLD 결과가 나왔는데, 80점으로 합격했다. 기대했던 것보다는 좋지 못한 점수이지만, 합격을 했다는 부분에 의의를 두려고 한다.

요즘 체력적으로 좀 후달리고 그로 인해 집중력이나 사고력도 흐트러지는 것 같다. 가벼운 산책부터 시작해서 운동을 좀 더 루틴화해야겠다.