feat: 프로그래머스 알고리즘 문제 복습

Author: skyleedevzero86

src/com/algorithm2025/backjoon3/day005/Example20250630_Q_L697.java

@@ -0,0 +1,5 @@
+package com.algorithm2025.backjoon3.day005;
+
+public class Example20250630_Q_L697 { // lettcode 번외 697번 Degree of an Array
+
+}

src/com/algorithm2025/backjoon3/day006/Example20250716_Q68937.java

@@ -0,0 +1,78 @@
+package com.algorithm2025.backjoon3.day006;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Example20250716_Q68937 { // 코딩테스트 연습 월간 코드 챌린지 시즌1 트리 트리오 중간값
+
+    static ArrayList<Integer>[] board;
+
+    public static int[] bfs(int idx, int n) {
+        int[] visited = new int[n+1];
+        Arrays.fill(visited, -1);
+        Queue<Integer> q = new LinkedList<Integer>();
+        q.offer(idx);
+        visited[idx] = 0;
+
+        int[] max = {0, 0, 0};
+
+        while (!q.isEmpty()) {
+            int old = q.poll();
+            for (int newIdx : board[old]) {
+                if (visited[newIdx] == -1) {
+                    visited[newIdx] = visited[old] + 1;
+                    q.offer(newIdx);
+
+                    if (max[0] < visited[newIdx]) {
+                        max[0] = visited[newIdx];
+                        max[1] = newIdx;
+                        max[2] = 1;
+                    } else if (max[0] == visited[newIdx]) {
+                        max[2]++;
+                        max[1] = newIdx;
+                    }
+                }
+            }
+        }
+
+        return max;
+    }
+
+    public static int solution(int n, int[][] edges) {
+        board = new ArrayList[n+1];
+        for (int i = 1; i <= n; i++) {
+            board[i] = new ArrayList<Integer>();
+        }
+
+        int answer = 0;
+        int max_value = -1;
+
+        for (int[] edge : edges) {
+            int i = edge[0];
+            int j = edge[1];
+            board[i].add(j);
+            board[j].add(i);
+        }
+        int[] temp = bfs(1, n);
+        int[] temp2 = bfs(temp[1], n);
+
+        if (temp2[2] >= 2) {
+            return temp2[0];
+        }
+
+        else {
+            int[] temp3 = bfs(temp2[1], n);
+
+            if (temp3[2] >= 2) {
+                return temp3[0];
+            }
+
+            else {
+                return temp3[0]-1;
+            }
+        }
+    }
+
+}

src/com/algorithm2025/backjoon3/day006/Example20250716_Q84021.java

@@ -0,0 +1,149 @@
+package com.algorithm2025.backjoon3.day006;
+
+import java.util.*;
+
+public class Example20250716_Q84021 { //코딩테스트 연습 깊이/너비 우선 탐색(DFS/BFS)  퍼즐 조각 채우기
+
+    List<List<Point>> t = new ArrayList<>();
+    List<List<Point>> g = new ArrayList<>();
+    int[] dx = {0, 0, 1, -1};
+    int[] dy = {1, -1, 0, 0};
+
+    public int Example20250716_Q84021(int[][] game_board, int[][] table) {
+        int answer = 0;
+
+        int len = game_board.length;
+
+        for (int i = 0; i < len; i++) {
+            for (int j = 0; j < len; j++) {
+                game_board[i][j] = game_board[i][j] == 0 ? 1 : 0;
+            }
+        }
+
+        boolean[][] visited_t = new boolean[len][len];
+        boolean[][] visited_g = new boolean[len][len];
+
+        for (int i = 0; i < len; i++) {
+            for (int j = 0; j < len; j++) {
+                if (table[i][j] == 1 && !visited_t[i][j])
+                    bfs(i, j, table, visited_t, t);
+
+                if (game_board[i][j] == 1 && !visited_g[i][j])
+                    bfs(i, j, game_board, visited_g, g);
+            }
+        }
+
+        answer = compareBlock(t, g, answer);
+
+        return answer;
+    }
+
+    public int compareBlock(List<List<Point>> table, List<List<Point>> board, int answer) {
+        int table_size = table.size();
+        int board_size = board.size();
+
+        boolean[] visited = new boolean[board_size];
+
+        for (int i = 0; i < table_size; i++) {
+            for (int j = 0; j < board_size; j++) {
+                // 일치하면
+                if (visited[j] || table.get(i).size() != board.get(j).size())
+                    continue;
+                if (isRotate(table.get(i), board.get(j))) {
+                    visited[j] = true; // 블록으로 채워짐
+                    answer += board.get(j).size();
+                    break;
+                }
+            }
+        }
+
+        return answer;
+    }
+
+    public boolean isRotate(List<Point> table, List<Point> board) {
+
+        Collections.sort(board);
+
+        for (int i = 0; i < 4; i++) {
+
+            Collections.sort(table);
+
+            int curr_x = table.get(0).x;
+            int curr_y = table.get(0).y;
+
+            for (int j = 0; j < table.size(); j++) {
+                table.get(j).x -= curr_x;
+                table.get(j).y -= curr_y;
+            }
+
+            boolean check = true;
+
+            for (int j = 0; j < board.size(); j++) {
+                if (board.get(j).x != table.get(j).x || board.get(j).y != table.get(j).y) {
+                    check = false;
+                    break;
+                }
+            }
+
+            if (check) {
+                return true;
+            } else {
+
+                for (int j = 0; j < table.size(); j++) {
+                    int temp = table.get(j).x;
+                    table.get(j).x = table.get(j).y;
+                    table.get(j).y = -temp;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public void bfs(int x, int y, int[][] board, boolean[][] visited, List<List<Point>> list) {
+        visited[x][y] = true;
+
+        Queue<Point> q = new LinkedList<>();
+        q.add(new Point(x, y));
+
+        List<Point> sub_list = new ArrayList<>();
+        sub_list.add(new Point(0, 0));
+
+        while (!q.isEmpty()) {
+            Point p = q.poll();
+
+            for (int i = 0; i < 4; i++) {
+                int nx = p.x + dx[i];
+                int ny = p.y + dy[i];
+
+                if (nx < 0 || ny < 0 || nx >= board.length || ny >= board.length)
+                    continue;
+
+                if (!visited[nx][ny] && board[nx][ny] == 1) {
+                    visited[nx][ny] = true;
+                    q.add(new Point(nx, ny));
+                    sub_list.add(new Point(nx - x, ny - y));
+                }
+            }
+        }
+
+        list.add(sub_list);
+    }
+
+    static class Point implements Comparable<Point> {
+        int x, y;
+
+        Point(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int compareTo(Point o) {
+            int res = Integer.compare(this.x, o.x);
+            if (res == 0) {
+                res = Integer.compare(this.y, o.y);
+            }
+            return res;
+        }
+    }
+}

src/com/algorithm2025/backjoon3/day006/Example20250716_Q86053.java

@@ -0,0 +1,43 @@
+package com.algorithm2025.backjoon3.day006;
+
+public class Example20250716_Q86053 {
+
+    public long Example20250716_Q86053(int a, int b, int[] g, int[] s, int[] w, int[] t) {
+        long answer = Long.MAX_VALUE;
+        long start = 0;
+        long end = 4 * (long)Math.pow(10, 14);
+
+        while (start <= end) {
+            long mid = (start + end) / 2;
+            long gold = 0;
+            long silver = 0;
+            long add = 0;
+
+            for (int i = 0; i < t.length; i++) {
+                long nowG = g[i];
+                long nowS = s[i];
+                long nowW = w[i];
+                long nowT = t[i];
+
+                long moveCount = mid / (nowT * 2);
+                if (mid % (nowT * 2) >= nowT) {
+                    moveCount += 1;
+                }
+
+                gold += Math.min(nowG, moveCount * nowW);
+                silver += Math.min(nowS, moveCount * nowW);
+                add += Math.min(nowG + nowS, moveCount * nowW);
+            }
+
+            if (gold >= a && silver >= b && add >= (a + b)) {
+                answer = Math.min(mid, answer);
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+
+        return answer;
+    }
+
+}

src/com/algorithm2025/backjoon3/day006/Example20250716_Q92345.java

@@ -0,0 +1,47 @@
+package com.algorithm2025.backjoon3.day006;
+
+public class Example20250716_Q92345 { //코딩테스트 연습 2022 KAKAO BLIND RECRUITMENT 사라지는 발판
+
+
+    int[] dx = {0, 0, -1, 1};
+    int[] dy = {-1, 1, 0, 0};
+    int n, m;
+
+    boolean OOB(int x, int y) {
+        return x < 0 || x >= n || y < 0 || y >= m;
+    }
+
+    int[][] vis = new int[5][5];
+    int[][] block = new int[5][5];
+
+    int solve(int curx, int cury, int opx, int opy) {
+        if (vis[curx][cury] == 1) return 0;
+        int ret = 0;
+        for (int dir = 0; dir < 4; dir++) {
+            int nx = curx + dx[dir];
+            int ny = cury + dy[dir];
+            if (OOB(nx, ny) || vis[nx][ny] == 1 || block[nx][ny] == 0) continue;
+            vis[curx][cury] = 1;
+
+            int val = solve(opx, opy, nx, ny) + 1;
+
+            vis[curx][cury] = 0;
+
+            if (ret % 2 == 0 && val % 2 == 1) ret = val;
+            else if (ret % 2 == 0 && val % 2 == 0) ret = Math.max(ret, val);
+            else if (ret % 2 == 1 && val % 2 == 1) ret = Math.min(ret, val);
+        }
+        return ret;
+    }
+
+    public int Example20250716_Q92345(int[][] board, int[] aloc, int[] bloc) {
+        n = board.length;
+        m = board[0].length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                block[i][j] = board[i][j];
+            }
+        }
+        return solve(aloc[0], aloc[1], bloc[0], bloc[1]);
+    }
+}