허준혁 / 11월 3주차 / 월, 목

HuhJunHyeok/boj/boj1068.java

@@ -0,0 +1,72 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+/**
+ * [boj] 1068. 트리
+ */
+public class boj1068 {
+    /**
+     * N: 트리의 노드 수, rootNode: 루트 노드의 번호, removeNode: 지울 노드의 번호, leafNodeCount: 리프 노드의 수
+     */
+    static int N, rootNode, removeNode, leafNodeCount;
+    /**
+     * parents: 각 노드의 부모 노드
+     */
+    static int[] parents;
+    static boolean[] visited;
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        N = Integer.parseInt(br.readLine());
+
+        parents = new int[N];
+        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
+        for(int i = 0; i < N; i++) {
+            parents[i] = Integer.parseInt(st.nextToken());
+
+            if(parents[i] == -1) {
+                rootNode = i;
+            }
+        }
+
+        removeNode = Integer.parseInt(br.readLine());
+
+        remove(removeNode);
+        visited = new boolean[N];
+        countLeafNode(rootNode);
+
+        System.out.println(leafNodeCount);
+    }
+
+
+    public static void remove(int removeNode) {
+        parents[removeNode] = -2; // 제거한 노드의 부모 노드를 사용할 수 없는 수인 -2로 변경.
+
+        for(int i = 0; i < N; i++) {
+            if(parents[i] == removeNode) {
+                remove(i);
+            }
+        }
+    }
+
+    public static void countLeafNode(int node) {
+        visited[node] = true;
+        boolean isLeafNode = true;
+
+        if(parents[node] != -2) {
+            for(int i = 0; i < N; i++) {
+                if(parents[i] != node || visited[i]) {
+                    continue;
+                }
+                countLeafNode(i);
+                isLeafNode = false;
+            }
+
+            if(isLeafNode) {
+                leafNodeCount++;
+            }
+        }
+    }
+}

HuhJunHyeok/boj/boj20046.java

@@ -0,0 +1,106 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+/**
+ * [boj] 20046. Road Reconstruction
+ */
+public class boj20046 {
+    /**
+     * m: 행, n: 열
+     */
+    static int m, n;
+    /**
+     * map: 도시를 의미하는 격자
+     * 각 열의 정보는 정수 0, 1, 2, -1 로 나타내며
+     * 0 은 단위도로가 이미 존재하는 것을, 즉, 도로에 유실이 없는 상태,
+     * 1 은 단위 도로가 없고 1 의 비용으로 도로를 건설할 수 있는 단위 격자,
+     * 2 는 단위 도로가 없고 2 의 비용으로 도로를 건설할 수 있는 단위 격자를 의미한다.
+     * -1 은 X로 표시된 단위 격자로 그 위치에 단위 도로를 건설할 수 없는 상태를 의미한다.
+     *
+     * cost: 필요 비용
+     */
+    static int[][] map, cost;
+    static int[] dr = {-1, 1, 0, 0}, dc = {0, 0, -1, 1};
+    static final int MAX = Integer.MAX_VALUE;
+    static class Vertex implements Comparable<Vertex> {
+        int r;
+        int c;
+        int cost;
+
+        public Vertex(int r, int c, int cost) {
+            this.r = r;
+            this.c = c;
+            this.cost = cost;
+        }
+
+        @Override
+        public int compareTo(Vertex o) {
+            return Integer.compare(this.cost, o.cost);
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
+
+        m = Integer.parseInt(st.nextToken());
+        n = Integer.parseInt(st.nextToken());
+
+        map = new int[m + 1][n + 1];
+        cost = new int[m + 1][n + 1];
+        for(int i = 1; i <= m; i++) {
+            st = new StringTokenizer(br.readLine(), " ");
+            for(int j = 1; j <= n; j++) {
+                map[i][j] = Integer.parseInt(st.nextToken());
+                cost[i][j] = MAX;
+            }
+        }
+
+        if(map[1][1] == - 1 || map[m][n] == -1) {
+            System.out.println(-1);
+            return;
+        }
+
+        dijkstra();
+
+        System.out.println(cost[m][n] == MAX ? -1 : cost[m][n]);
+    }
+
+    public static void dijkstra() {
+        PriorityQueue<Vertex> pq = new PriorityQueue<>();
+        pq.offer(new Vertex(1, 1, map[1][1]));
+
+        while(!pq.isEmpty()) {
+            Vertex now = pq.poll();
+
+            if(cost[now.r][now.c] < now.cost) {
+                continue;
+            }
+
+            if(now.r == m && now.c == n) {
+                return;
+            }
+
+            for(int i = 0; i < 4; i++) {
+                int nextR = now.r + dr[i];
+                int nextC = now.c + dc[i];
+
+                if(!isIn(nextR, nextC) || map[nextR][nextC] == -1) {
+                    continue;
+                }
+
+                if(cost[nextR][nextC] > now.cost + map[nextR][nextC]) {
+                    cost[nextR][nextC] = now.cost + map[nextR][nextC];
+
+                    pq.offer(new Vertex(nextR, nextC, cost[nextR][nextC]));
+                }
+            }
+        }
+    }
+
+    public static boolean isIn(int r, int c) {
+        return 1 <= r && r <= m && 1 <= c && c <= n;
+    }
+}

HuhJunHyeok/boj/boj2251.java

@@ -0,0 +1,96 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+import java.util.TreeSet;
+
+/**
+ * [boj] 2251. 물통
+ */
+public class boj2251 {
+    static int[] maxWaterOfBottles = new int[3];
+    static int maxWater;
+    static boolean[][] visited;
+    static TreeSet<Integer> cWaters = new TreeSet<>();
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
+        StringBuilder sb = new StringBuilder();
+
+        for(int i = 0; i < 3; i++) {
+            maxWaterOfBottles[i] = Integer.parseInt(st.nextToken());
+
+            if(maxWaterOfBottles[i] > maxWater) {
+                maxWater = maxWaterOfBottles[i];
+            }
+        }
+        visited = new boolean[maxWater + 1][maxWater + 1];
+
+        dfs(0, 0, maxWaterOfBottles[2]);
+
+        for(int water: cWaters) {
+            sb.append(water).append(" ");
+        }
+        sb.append("\n");
+
+        System.out.print(sb.toString());
+    }
+
+    public static void dfs(int a, int b, int c) {
+        if(visited[a][b]) {
+            return;
+        }
+
+        if(a == 0) {
+            cWaters.add(c);
+        }
+
+        visited[a][b] = true;
+
+        int ab = a + b;
+        int ac = a + c;
+        int bc = b + c;
+
+        // a to b
+        if(ab > maxWaterOfBottles[1]) {
+            dfs(ab - maxWaterOfBottles[1], maxWaterOfBottles[1], c);
+        } else {
+            dfs(0, ab, c);
+        }
+
+        // a to c
+        if(ac > maxWaterOfBottles[2]) {
+            dfs(ac - maxWaterOfBottles[2], b, maxWaterOfBottles[2]);
+        } else {
+            dfs(0, b, ac);
+        }
+
+        // b to a
+        if(ab > maxWaterOfBottles[0]) {
+            dfs(maxWaterOfBottles[0], ab - maxWaterOfBottles[0], c);
+        } else {
+            dfs(ab, 0, c);
+        }
+
+        // b to c
+        if(bc > maxWaterOfBottles[2]) {
+            dfs(a, bc - maxWaterOfBottles[2], maxWaterOfBottles[2]);
+        } else {
+            dfs(a, 0, bc);
+        }
+
+        // c to a
+        if(ac > maxWaterOfBottles[0]) {
+            dfs(maxWaterOfBottles[0], b, ac - maxWaterOfBottles[0]);
+        } else {
+            dfs(ac, b, 0);
+        }
+
+        // c to b
+        if(bc > maxWaterOfBottles[1]) {
+            dfs(a, maxWaterOfBottles[1], bc - maxWaterOfBottles[1]);
+        } else {
+            dfs(a, bc, 0);
+        }
+    }
+}

HuhJunHyeok/boj/boj23284.java

@@ -0,0 +1,60 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+/**
+ * [boj] 23284. 모든 스택 수열
+ */
+public class boj23284 {
+    static int n;
+    static int[] sequence;
+    static StringBuilder sb = new StringBuilder();
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        n = Integer.parseInt(br.readLine());
+        sequence = new int[n];
+
+        solve(0, 0);
+
+        System.out.print(sb.toString());
+    }
+
+    public static void solve(int depth, int nextNum) {
+        if(depth == n) {
+            for(int i = 0; i < n; i++) {
+                sb.append(sequence[i]).append(" ");
+            }
+            sb.append("\n");
+
+            return;
+        }
+
+        for(int i = 1; i <= n; i++) { // 현재 숫자
+            boolean isDuplicateNum = false;
+
+            for(int j = 0; j < depth; j++) {
+                if(sequence[j] == i) {
+                    isDuplicateNum = true;
+                    break;
+                }
+            }
+
+            if(isDuplicateNum) {
+                continue;
+            }
+
+            sequence[depth] = i;
+
+            if(depth >= 1 && sequence[depth - 1] < sequence[depth] && sequence[depth] < nextNum) { // 이 경우 문제 조건을 만족하지 않는 수열
+                break;
+            }
+
+            if(sequence[depth] >= nextNum) { // 현재 들어오는 수가 새로운 수
+                solve(depth + 1, sequence[depth] + 1);
+            } else { // 현재 들어오는 수가 이미 들어온 수
+                solve(depth + 1, nextNum);
+            }
+        }
+    }
+}