3월 3주차

java/.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="out"/>
+</classpath>

java/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>java</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

java/src/jan/week2/boj/가희의고구마먹방_이다예.java

@@ -1,4 +1,4 @@
-package baekjoon.p21772;
+package jan.week2.boj;
 
 import java.io.BufferedReader;
 import java.io.InputStreamReader;

java/src/jan/week4/boj/너봄에는캡사이신이맛있단다_박재환.java

@@ -1,4 +1,4 @@
-package jan.week4;
+package jan.week4.boj;
 
 import java.io.*;
 import java.util.*;

java/src/mar/week3/boj/공장_박재환.java

@@ -0,0 +1,84 @@
+package mar.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 공장_박재환 {
+    static BufferedReader br;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        init();
+        br.close();
+    }
+    /**
+     * 2N 개의 기계가 2열에 걸쳐 N개씩 배치
+     * 각 열에 있는 기계는 짝을 이루어 연결되어 있음
+     * 식별번호 N개
+     */
+    static StringTokenizer st;
+    static int n;
+    static int[] arr1, arr2;
+    static Map<Integer, Integer> map;
+    static void init() throws IOException {
+        map = new HashMap<>();
+
+        n = Integer.parseInt(br.readLine().trim());
+        arr1 = new int[n];
+        arr2 = new int[n];
+
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=0; i<n;) arr1[i++] = Integer.parseInt(st.nextToken());
+
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=0; i<n; i++) {
+            arr2[i] = Integer.parseInt(st.nextToken());
+            map.put(arr2[i], i);
+        }
+
+        System.out.println(solution());
+    }
+    static long[] tree;
+    static long solution() {
+        bindLocation();
+        /**
+         * 현재 구간의 왼쪽에서, 현재 값보다 큰 값을 찾는다.
+         * => 세그먼트 트리로 구간을 빠르게 조회한다.
+         */
+        long result = 0;
+        tree = new long[4*n];
+        for(int i : loc) {
+            /**
+             * 각 노드 : 해당 범위에 등장한 값의 개수
+             *
+             * query : 현재 값(i) 기준, i+1 ~ n-1 까지의 수가 나온 횟수
+             * update : 현재 값 i 이 나온 개수를 업데이트
+             */
+            result += query(1, 0, n-1, i+1, n-1);
+            update(1, 0, n-1, i);
+        }
+        return result;
+    }
+    static int[] loc;
+    static void bindLocation() {
+        loc = new int[n];
+        for(int i=0; i<n; i++) loc[i] = map.get(arr1[i]);
+    }
+    static long query(int id, int l, int r, int s, int e)  {
+        if(r < s || l > e) return 0;
+        if(l >= s && r <= e) return tree[id];
+        int mid = l + (r - l)/2;
+        return query(2*id, l, mid, s, e)
+                + query(2*id+1, mid+1, r, s, e);
+    }
+    static void update(int id, int l, int r, int target) {
+        if(r < target || l > target) return ;
+        if(l == r) {
+            tree[id]++;
+            return;
+        }
+        int mid = l + (r - l)/2;
+        update(2*id, l, mid, target);
+        update(2*id+1, mid+1, r, target);
+        tree[id] = tree[2*id] + tree[2*id+1];
+    }
+}

java/src/mar/week3/boj/네트워크복구_박재환.java

@@ -0,0 +1,91 @@
+package mar.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 네트워크복구_박재환 {
+    static BufferedReader br;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        init();
+        br.close();
+    }
+    static StringTokenizer st;
+    static int n, m;
+    static List<int[]>[] connections;
+    static void init() throws IOException {
+        /**
+         * 연결 : 양방향
+         * 가중치가 존재
+         */
+        st = new StringTokenizer(br.readLine().trim());
+        n = Integer.parseInt(st.nextToken());       // 컴퓨터 개수
+        m = Integer.parseInt(st.nextToken());       // 회선 개수
+
+        connections = new List[n+1];
+        for(int i=0; i<n+1;) connections[i++] = new ArrayList<>();
+
+        while(m-- > 0) {
+            st = new StringTokenizer(br.readLine().trim());
+            int from = Integer.parseInt(st.nextToken());
+            int to = Integer.parseInt(st.nextToken());
+            int cost = Integer.parseInt(st.nextToken());
+
+            connections[from].add(new int[] {to, cost});
+            connections[to].add(new int[] {from, cost});
+        }
+
+        int[] result = findMinCost();
+
+        int count = 0;
+        List<int[]> finalRoute = new ArrayList<>();
+        for(int i=2; i<n+1; i++) {
+            int from = i;
+            int to = result[i];
+            count++;
+            finalRoute.add(new int[] {from, to});
+        }
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(count).append('\n');
+        for(int[] arr : finalRoute) sb.append(arr[0]).append(' ').append(arr[1]).append('\n');
+
+        System.out.println(sb);
+    }
+    static final int INF = 15 * 1000;
+    static int[] findMinCost() {
+        /**
+         * 다익스트라 + 역추적
+         * 최단 거리를 구한 뒤, 해당 거리를 구성하는 경로를 복원하는 것이 필요
+         */
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(a[1], b[1]));
+        int[] costDp = new int[n+1];
+        int[] prevDp = new int[n+1];
+        Arrays.fill(costDp, INF);
+
+        costDp[1] = 0;      // 슈퍼 컴퓨터
+        prevDp[1] = -1;     // 슈퍼 컴퓨터를 시작점으로 경로를 구함
+        pq.offer(new int[] {1, 0});
+
+        while(!pq.isEmpty()) {
+            int[] cur = pq.poll();
+            int from = cur[0];
+            int accCost = cur[1];
+
+            if(costDp[from] < accCost) continue;
+
+            for(int[] next : connections[from]) {
+                int to = next[0];
+                int cost = next[1];
+
+                if(costDp[from] != INF && costDp[to] > accCost + cost) {
+                    costDp[to] = accCost + cost;
+                    prevDp[to] = from;
+                    pq.offer(new int[] {to, costDp[to]});
+                }
+            }
+        }
+
+        return prevDp;
+    }
+}

java/src/mar/week3/boj/최종순위_박재환.java

@@ -0,0 +1,99 @@
+package mar.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 최종순위_박재환 {
+    static BufferedReader br;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        init();
+        br.close();
+    }
+    /**
+     * n 개의 팀 (1 ~ N)
+     * 작년에 비해서 상대적인 순위가 바뀐 팀의 순위만 알려준다.
+     * => 작년에 팀 13이 팀6보다 순위가 높았는데, 올해 팀 6이 13보다 순위가 높다면 (6, 13)
+     */
+    static StringTokenizer st;
+    static void init() throws IOException {
+        int t = Integer.parseInt(br.readLine().trim());
+        while(t-- > 0) {
+            int n = Integer.parseInt(br.readLine().trim());
+            int[] rank = new int[n+1];
+            st = new StringTokenizer(br.readLine().trim());
+            for(int i=1; i<n+1;) rank[i++] = Integer.parseInt(st.nextToken());
+            getInEdge(n, rank);
+
+            int q = Integer.parseInt(br.readLine().trim());
+            while(q-- > 0) {
+                st = new StringTokenizer(br.readLine().trim());
+                int a = Integer.parseInt(st.nextToken());
+                int b = Integer.parseInt(st.nextToken());
+                swap(a, b);
+            }
+
+            System.out.println(getRank(n));
+        }
+    }
+    static boolean[][] connections;
+    static int[] inEdge;
+    static void getInEdge(int n, int[] rank) {
+        connections = new boolean[n+1][n+1];
+        inEdge = new int[n+1];
+
+        for(int i=1; i<n+1; i++) {
+            int h = rank[i];
+            for(int j=i+1; j<n+1; j++) {
+                int l = rank[j];
+                if(!connections[h][l]) {
+                    connections[h][l] = true;
+                    inEdge[l]++;
+                }
+            }
+        }
+    }
+    static void swap(int a, int b) {
+        if (connections[a][b]) {
+            connections[a][b] = false;
+            inEdge[b]--;
+            connections[b][a] = true;
+            inEdge[a]++;
+        } else {
+            connections[b][a] = false;
+            inEdge[a]--;
+            connections[a][b] = true;
+            inEdge[b]++;
+        }
+    }
+    static String getRank(int n) {
+        Queue<Integer> q = new ArrayDeque<>();
+        for (int i = 1; i <= n; i++) {
+            if (inEdge[i] == 0) q.offer(i);
+        }
+
+        StringBuilder order = new StringBuilder();
+        boolean ambiguous = false;
+        int count = 0;
+
+        while (!q.isEmpty()) {
+            if (q.size() > 1) {
+                ambiguous = true;
+            }
+
+            int cur = q.poll();
+            order.append(cur).append(' ');
+            count++;
+
+            for (int i = 1; i <= n; i++) {
+                if (connections[cur][i]) {
+                    if (--inEdge[i] == 0) q.offer(i);
+                }
+            }
+        }
+
+        if (count < n) return "IMPOSSIBLE";
+        if (ambiguous) return "?";
+        return order.toString().trim();
+    }
+}

java/src/mar/week3/boj/할로윈의양아치_박재환.java

@@ -0,0 +1,83 @@
+package mar.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 할로윈의양아치_박재환 {
+    static BufferedReader br;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        init();
+        br.close();
+    }
+    static StringTokenizer st;
+    static int n, m, k;
+    static int[] candies;
+    static void init() throws IOException {
+        st = new StringTokenizer(br.readLine().trim());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        k = Integer.parseInt(st.nextToken());
+
+        candies = new int[n+1];
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=1; i<n+1;) candies[i++] = Integer.parseInt(st.nextToken());
+
+        make(n);
+        for(int i=0; i<m; i++) {
+            st = new StringTokenizer(br.readLine().trim());
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+            union(a, b);
+        }
+        makeGroupArr();
+        System.out.println(solution());
+    }
+    static int[][] groups;
+    static void makeGroupArr() {
+        groups = new int[n+1][2];
+        for(int i=1; i<n+1; i++) {
+            int gId = find(i);
+            int candy = candies[i];
+            groups[gId][0]++;
+            groups[gId][1]+=candy;
+        }
+    }
+    static int solution() {
+        int[] dp = new int[k];
+        for(int[] arr : groups) {
+            if(arr[1] == 0) continue;
+            for(int v=k-1; v>=arr[0]; v--) {
+                dp[v] = Math.max(dp[v-arr[0]] + arr[1], dp[v]);
+            }
+        }
+        return dp[k-1];
+    }
+    /**
+     * Union Find 를 이용해, 집합 단위로 묶어준다.
+     */
+    static int[] parents;
+    static int[] ranks;
+    static void make(int n) {
+        parents = new int[n+1];
+        ranks = new int[n+1];
+        for(int i=1; i<n+1; i++) parents[i] = i;
+    }
+    static int find(int a) {
+        if(parents[a] == a) return a;
+        return parents[a] = find(parents[a]);
+    }
+    static boolean union(int a, int b) {
+        int rootA = find(a);
+        int rootB = find(b);
+        if(rootA == rootB) return false;
+
+        if(ranks[rootA] > ranks[rootB]) parents[rootB] = rootA;
+        else if (ranks[rootA] < ranks[rootB]) parents[rootA] = rootB;
+        else {
+            parents[rootA] = rootB;
+            ranks[rootB]++;
+        }
+        return true;
+    }
+}