[김유성-13주차 알고리즘 스터디]

김유성-13주차/Main1507_궁금한민호.java

@@ -0,0 +1,111 @@
+package study13week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class Main1507_궁금한민호 {
+  static class Node implements Comparable<Node> {
+    int num;
+    int len;
+
+    public Node(int num, int len) {
+      this.num = num;
+      this.len = len;
+    }
+
+    @Override
+    public int compareTo(Node o) {
+      return Integer.compare(this.len, o.len);
+    }
+  }
+
+  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+  static StringTokenizer st;
+  static int N, dist[][], ret;
+
+  public static void main(String[] args) throws IOException {
+      init();
+      if (!isOk()) {
+        System.out.println(-1);
+        return;
+      }
+
+      for (int i = 0; i < N - 1; i++) {
+        for (int j = i + 1; j < N; j++) {
+          int temp = dist[i][j];
+          dist[i][j] = 0;
+          dist[j][i] = 0;
+
+          if (bfs(i, j) > temp) {// i - j 간선을 지운다.
+            dist[i][j] = temp;
+            dist[j][i] = temp;
+          } else {
+            ret -= temp;
+          }
+        }
+      }
+
+      System.out.println(ret);
+  }
+
+  static boolean isOk() {
+    for (int i = 0; i < N; i++) {
+      for (int j = 0; j < N; j++) {
+        if (i == j) continue;
+        for (int k = 0; k < N; k++) {
+          if (j == k || i == k) continue;
+          if (dist[i][j] > dist[i][k] + dist[k][j]) { // 직선 거리로 가는게 더 클 때
+            return false;
+          } 
+        }
+      }
+    }
+    return true;
+  }
+
+  static int bfs(int a, int b) {
+    PriorityQueue<Node> pq = new PriorityQueue<>();
+    int[][] distance = new int [N][N];
+    for (int i = 0; i < N; i++) {
+      Arrays.fill(distance[i], Integer.MAX_VALUE);
+    }
+
+    distance[a][a] = 0;
+    pq.add(new Node(a, 0));
+
+    while (!pq.isEmpty()) {
+      Node n = pq.poll();
+
+      if (n.num == b) {
+        return n.len;
+      }
+
+      for (int i = 0; i < N; i++) {
+        if (dist[n.num][i] > 0 && distance[n.num][i] > n.len) {
+          distance[n.num][i] = n.len;
+          pq.add(new Node(i, dist[n.num][i] + n.len));
+        }
+      }
+    }
+
+    return Integer.MAX_VALUE;
+  }
+
+  static void init() throws IOException {
+    N = Integer.parseInt(br.readLine());
+
+    dist = new int [N][N];
+    for (int i = 0; i < N; i++) {
+      st = new StringTokenizer(br.readLine());
+      for (int j = 0; j < N; j++) {
+        dist[i][j] = Integer.parseInt(st.nextToken());
+        ret += dist[i][j];
+      }
+    }
+    ret /= 2;
+  }
+}

김유성-13주차/Main1561_놀이공원.java

@@ -0,0 +1,134 @@
+package study13week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class Main1561_놀이공원 {
+  static class Ride implements Comparable<Ride> {
+    int num, time, isRide; // isRide: 남은 시간. 0이면 탑승 가능
+
+    public Ride(int num, int time, int isRide) {
+      this.num = num;
+      this.time = time;
+      this.isRide = isRide;
+    }
+
+    @Override
+    public int compareTo(Ride o) {
+      int comp = Integer.compare(this.isRide, o.isRide);
+      if (comp == 0)
+        return Integer.compare(this.num, o.num);
+      return comp;
+    }
+  }
+
+  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+  static StringTokenizer st;
+  static int N, M, play[];
+
+  public static void main(String[] args) throws IOException {
+    init();
+    if (N < M) {
+      for (int i = 0; i < M; i++) {
+        if (--N == 0) {
+          System.out.println(i + 1);
+          return;
+        }
+      }
+    } else if (N == M) {
+      System.out.println(M);
+    } else {
+      long time = getTime();
+      solve(time);
+    }
+  }
+
+  static void solve(long time) {
+    PriorityQueue<Ride> pq = new PriorityQueue<>();
+
+    // 남은 아이들의 수를 구한다. 만약 딱 나누어 떨어지지 않는다면 아직 놀이기구에 탑승한 상태이다.
+    for (int i = 0; i < M; i++) {
+      N -= time / play[i];
+      if (time % play[i] == 0) {
+        pq.add(new Ride(i + 1, play[i], 0));
+      } else {
+        pq.add(new Ride(i + 1, play[i], play[i] - (int) time % play[i]));
+        N--;
+      }
+    }
+
+    Queue<Ride> temp = new LinkedList<>();
+
+    while (true) {
+      for (int i = 0; i < M; i++) {
+        Ride ride = pq.poll();
+
+        if (ride.isRide == 0) {
+          ride.isRide = ride.time - 1;
+          N--;
+        } else 
+          ride.isRide--;
+        temp.add(ride);
+
+        if (N == 0) {
+          System.out.println(ride.num);
+          return;
+        }
+      }
+
+      while (!temp.isEmpty()) {
+        pq.add(temp.poll());
+      }
+    }
+
+  }
+
+  static long getTime() {
+    long start = 1;
+    long end = 60_000_000_000L;
+    long mid = 0; // 놀이기구를 탔을 때 걸리는 시간
+    while (start < end - 1) {
+      mid = (start + end) / 2;
+      long child = getCount(mid);
+
+      if (child >= N) {
+        end = mid - 1;
+      } else {
+        start = mid;
+      }
+    }
+
+    return start;
+  }
+
+  static long getCount(long time) {
+    long ret = 0;
+    for (int i = 0; i < M; i++) {
+      ret += time / play[i];
+
+      // 딱 나누어 떨어지지 않으면 놀이기구에 탑승한 아이가 있는상태. 그 아이의 인원수도 계산해준다.
+      if (time / play[i] > 0 && time % play[i] != 0)
+        ret++;
+    }
+
+    return ret;
+  }
+
+  static void init() throws IOException {
+    st = new StringTokenizer(br.readLine());
+    N = Integer.parseInt(st.nextToken());
+    M = Integer.parseInt(st.nextToken());
+
+    play = new int[M];
+
+    st = new StringTokenizer(br.readLine());
+    for (int i = 0; i < M; i++) {
+      play[i] = Integer.parseInt(st.nextToken());
+    }
+  }
+}

김유성-13주차/Main16940_BFS스페셜저지.java

@@ -0,0 +1,99 @@
+package study13week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class Main16940_BFS스페셜저지 {
+
+  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+  static StringTokenizer st;
+  static int N;
+  static List<Integer>[] nodes;
+  static boolean[] visited;
+  static Queue<Integer> input = new LinkedList<>();
+  static boolean isOk = true;
+
+  public static void main(String[] args) throws IOException {
+    init();
+    solve(input.poll());
+    if (isOk)
+      System.out.println(1);
+    else
+      System.out.println(0);
+  }
+
+  static void solve(int index) {
+    if (index != 1) {
+      isOk = false;
+      return;
+    }
+    Queue<HashSet<Integer>> q = new LinkedList<>();
+
+    visited[index] = true;
+    HashSet<Integer> set = new HashSet<>();
+    for (int a: nodes[index]) {
+      if (!visited[a])
+        set.add(a);
+    }
+    q.add(set);
+
+    while (!input.isEmpty()) {
+      int size = q.size();
+
+      while (size-- > 0) {
+        HashSet<Integer> s = q.poll();
+
+        while (!s.isEmpty()) {
+          int next = input.poll();
+
+          HashSet<Integer> new_set = new HashSet<>();
+          if (!s.contains(next)) {
+            isOk = false;
+            return;
+          }
+
+          visited[next] = true;
+          for (int a: nodes[next]) {
+            if (!visited[a])
+              new_set.add(a);
+          }
+          q.add(new_set);
+          s.remove(next);
+        }
+
+      }
+    }
+  }
+
+  static void init() throws IOException {
+    N = Integer.parseInt(br.readLine());
+
+    nodes = new ArrayList[N + 1];
+    visited = new boolean[N + 1];
+
+    for (int i = 1; i <= N; i++) {
+      nodes[i] = new ArrayList<>();
+    }
+
+    for (int i = 0; i < N - 1; i++) {
+      st = new StringTokenizer(br.readLine());
+      int from = Integer.parseInt(st.nextToken());
+      int to = Integer.parseInt(st.nextToken());
+
+      nodes[from].add(to);
+      nodes[to].add(from);
+    }
+
+    st = new StringTokenizer(br.readLine());
+    for (int i = 0; i < N; i++)
+      input.add(Integer.parseInt(st.nextToken()));
+
+  }
+}