Update

Author: ndb796

13/1.java

@@ -0,0 +1,64 @@
+import java.util.*;
+
+public class Main {
+
+    // 도시의 개수, 도로의 개수, 거리 정보, 출발 도시 번호
+    public static int n, m, k, x;
+    public static ArrayList<ArrayList<Integer>> graph = new ArrayList<ArrayList<Integer>>();
+    // 모든 도시에 대한 최단 거리 초기화
+    public static int[] d = new int[300001];
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        n = sc.nextInt();
+        m = sc.nextInt();
+        k = sc.nextInt();
+        x = sc.nextInt();
+
+        // 그래피 및 최단 거리 테이블 초기화
+        for (int i = 0; i <= n; i++) {
+            graph.add(new ArrayList<Integer>());
+            d[i] = -1;
+        }
+
+        // 모든 도로 정보 입력 받기
+        for (int i = 0; i < m; i++) {
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            graph.get(a).add(b);
+        }
+
+        // 출발 도시까지의 거리는 0으로 설정
+        d[x] = 0;
+
+        // 너비 우선 탐색(BFS) 수행
+        Queue<Integer> q = new LinkedList<Integer>();
+        q.offer(x);
+        while (!q.isEmpty()) {
+            int now = q.poll();
+            // 현재 도시에서 이동할 수 있는 모든 도시를 확인
+            for (int i = 0; i < graph.get(now).size(); i++) {
+                int nextNode = graph.get(now).get(i);
+                // 아직 방문하지 않은 도시라면
+                if (d[nextNode] == -1) {
+                    // 최단 거리 갱신
+                    d[nextNode] = d[now] + 1;
+                    q.offer(nextNode);
+                }
+            }
+        }
+
+        // 최단 거리가 K인 모든 도시의 번호를 오름차순으로 출력
+        boolean check = false;
+        for (int i = 1; i <= n; i++) {
+            if (d[i] == k) {
+                System.out.println(i);
+                check = true;
+            }
+        }
+
+        // 만약 최단 거리가 K인 도시가 없다면, -1 출력
+        if (!check) System.out.println(-1);
+    }
+}

13/2.java

@@ -0,0 +1,92 @@
+import java.util.*;
+
+public class Main {
+
+    public static int n, m, result = 0;
+    public static int[][] arr = new int[8][8]; // 초기 맵 배열
+    public static int[][] temp = new int[8][8]; // 벽을 설치한 뒤의 맵 배열
+    
+    // 4가지 이동 방향에 대한 배열
+    public static int[] dx = {-1, 0, 1, 0};
+    public static int[] dy = {0, 1, 0, -1};
+
+    // 깊이 우선 탐색(DFS)을 이용해 각 바이러스가 사방으로 퍼지도록 하기
+    public static void virus(int x, int y) {
+        for (int i = 0; i < 4; i++) {
+            int nx = x + dx[i];
+            int ny = y + dy[i];
+            // 상, 하, 좌, 우 중에서 바이러스가 퍼질 수 있는 경우
+            if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
+                if (temp[nx][ny] == 0) {
+                    // 해당 위치에 바이러스 배치하고, 다시 재귀적으로 수행
+                    temp[nx][ny] = 2;
+                    virus(nx, ny);
+                }
+            }
+        }
+    }
+
+    // 현재 맵에서 안전 영역의 크기 계산하는 메서드
+    public static int getScore() {
+        int score = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (temp[i][j] == 0) {
+                    score += 1;
+                }
+            }
+        }
+        return score;
+    }
+
+    // 깊이 우선 탐색(DFS)을 이용해 울타리를 설치하면서, 매 번 안전 영역의 크기 계산
+    public static void dfs(int count) {
+        // 울타리가 3개 설치된 경우
+        if (count == 3) {
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    temp[i][j] = arr[i][j];
+                }
+            }
+            // 각 바이러스의 위치에서 전파 진행
+            for (int i = 0; i < n; i++) {
+                for (int j = 0; j < m; j++) {
+                    if (temp[i][j] == 2) {
+                        virus(i, j);
+                    }
+                }
+            }
+            // 안전 영역의 최대값 계산
+            result = Math.max(result, getScore());
+            return;
+        }
+        // 빈 공간에 울타리를 설치
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (arr[i][j] == 0) {
+                    arr[i][j] = 1;
+                    count += 1;
+                    dfs(count);
+                    arr[i][j] = 0;
+                    count -= 1;
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        n = sc.nextInt();
+        m = sc.nextInt();
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = sc.nextInt();
+            }
+        }
+
+        dfs(0);
+        System.out.println(result);
+    }
+}

13/3.java

@@ -0,0 +1,104 @@
+import java.util.*;
+
+class Virus  implements Comparable<Virus> {
+
+    private int index;
+    private int second;
+    private int x;
+    private int y;
+
+    public Virus(int index, int second, int x, int y) {
+        this.index = index;
+        this.second = second;
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+
+    public int getSecond() {
+        return this.second;
+    }
+
+    public int getX() {
+        return this.x;
+    }
+
+    public int getY() {
+        return this.y;
+    }
+
+    // 정렬 기준은 '번호가 낮은 순서'
+    @Override
+    public int compareTo(Virus other) {
+        if (this.index < other.index) {
+            return -1;
+        }
+        return 1;
+    }
+}
+
+public class Main {
+
+    public static int n, k;
+    // 전체 보드 정보를 담는 배열
+    public static int[][] graph = new int[200][200];
+    public static ArrayList<Virus> viruses = new ArrayList<Virus>();
+    
+    // 바이러스가 퍼져나갈 수 있는 4가지의 위치
+    public static int[] dx = {-1, 0, 1, 0};
+    public static int[] dy = {0, 1, 0, -1};
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        n = sc.nextInt();
+        k = sc.nextInt();
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                graph[i][j] = sc.nextInt();
+                // 해당 위치에 바이러스가 존재하는 경우
+                if (graph[i][j] != 0) {
+                    // (바이러스 종류, 시간, 위치 X, 위치 Y) 삽입
+                    viruses.add(new Virus(graph[i][j], 0, i, j));
+                }
+            }
+        }
+
+        // 정렬 이후에 큐로 옮기기 (낮은 번호의 바이러스가 먼저 증식하므로)
+        Collections.sort(viruses);
+        Queue<Virus> q = new LinkedList<Virus>();
+        for (int i = 0; i < viruses.size(); i++) {
+            q.offer(viruses.get(i));
+        }
+
+        int targetS = sc.nextInt();
+        int targetX = sc.nextInt();
+        int targetY = sc.nextInt();
+
+        // 너비 우선 탐색(BFS) 진행
+        while (!q.isEmpty()) {
+            Virus virus = q.poll();
+            // 정확히 second만큼 초가 지나거나, 큐가 빌 때까지 반복
+            if (virus.getSecond() == targetS) break;
+            // 현재 노드에서 주변 4가지 위치를 각각 확인
+            for (int i = 0; i < 4; i++) {
+                int nx = virus.getX() + dx[i];
+                int ny = virus.getY() + dy[i];
+                // 해당 위치로 이동할 수 있는 경우
+                if (0 <= nx && nx < n && 0 <= ny && ny < n) {
+                    // 아직 방문하지 않은 위치라면, 그 위치에 바이러스 넣기
+                    if (graph[nx][ny] == 0) {
+                        graph[nx][ny] = virus.getIndex();
+                        q.offer(new Virus(virus.getIndex(), virus.getSecond() + 1, nx, ny));
+                    }
+                }
+            }
+        }
+
+        System.out.println(graph[targetX - 1][targetY - 1]);
+    }
+}

13/5.java

@@ -0,0 +1,69 @@
+import java.util.*;
+
+public class Main {
+
+    public static int n;
+    // 연산을 수행하고자 하는 수 리스트
+    public static ArrayList<Integer> arr = new ArrayList<>();
+    // 더하기, 빼기, 곱하기, 나누기 연산자 개수
+    public static int add, sub, mul, divi;
+    
+    // 최솟값과 최댓값 초기화
+    public static int minValue = (int) 1e9;
+    public static int maxValue = (int) -1e9;
+
+    // 깊이 우선 탐색 (DFS) 메서드
+    public static void dfs(int i, int now) {
+        // 모든 연산자를 다 사용한 경우, 최솟값과 최댓값 업데이트
+        if (i == n) {
+            minValue = Math.min(minValue, now);
+            maxValue = Math.max(maxValue, now);
+        }
+        else {
+            // 각 연산자에 대하여 재귀적으로 수행
+            if (add > 0) {
+                add -= 1;
+                dfs(i + 1, now + arr.get(i));
+                add += 1;
+            }
+            if (sub > 0) {
+                sub -= 1;
+                dfs(i + 1, now - arr.get(i));
+                sub += 1;
+            }
+            if (mul > 0) {
+                mul -= 1;
+                dfs(i + 1, now * arr.get(i));
+                mul += 1;
+            }
+            if (divi > 0) {
+                divi -= 1;
+                dfs(i + 1, now / arr.get(i));
+                divi += 1;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        n = sc.nextInt();
+
+        for (int i = 0; i < n; i++) {
+            int x = sc.nextInt();
+            arr.add(x);
+        }
+
+        add = sc.nextInt();
+        sub = sc.nextInt();
+        mul = sc.nextInt();
+        divi = sc.nextInt();
+
+        // DFS 메서드 호출
+        dfs(1, arr.get(0));
+
+        // 최댓값과 최솟값 차례대로 출력
+        System.out.println(maxValue);
+        System.out.println(minValue);
+    }
+}