[9주차] 이예진

BOJ/1000-5000번/YJ_2098.java

@@ -0,0 +1,55 @@
+import java.io.*;
+import java.util.*;
+
+public class YJ_2098 {
+    static int N;
+    static int[][] route;
+    static int[][] dp;
+    static final int INF = 16_000_001;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        N = Integer.parseInt(br.readLine());
+        route = new int[N][N];
+        dp = new int[1<<N][N]; //N개의 도시를 방문하는 모든 가능한 상태 (1<<N 은 2^N)
+
+        for(int i = 0; i < N; i++){
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for(int j = 0; j < N; j++){
+                route[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+        System.out.println(travelling(1,0));    //비트마스킹 1 은 방문완료
+    }
+
+
+    static int travelling(int visited, int now){
+        if(visited == (1<<N)-1){    //모든 도시를 다 방문했는지 체크. 만약 N=4 일 경우 1<<N)-1 은 01111 즉, visited 가 1111 이라면 모든 도시를 다 방문했다는 뜻
+            if(route[now][0] > 0){
+                return route[now][0];
+            }
+            return INF;
+        }
+
+        if(dp[visited][now] > 0){   //값이 0 이상인 경우 메모리제이션 완료
+            return dp[visited][now];
+        }
+        dp[visited][now] = INF; //해당 경로는 방문 전으로 최소값을 찾기위해 최대값으로 초기화
+
+        for(int next=0; next < N; next++){
+            if(stop(visited, now, next)){
+                continue;
+            }
+            dp[visited][now] = Math.min(
+                    dp[visited][now], travelling(visited |(1<<next),next) + route[now][next]
+            );
+        }
+
+        return dp[visited][now];
+    }
+
+    // 도시 i에서 도시 j로 갈 수 없고, 다음에 이동할 도시를 이미 순회했을 경우
+    private static boolean stop (int visited, int now, int next){
+        return route[now][next] == 0 || (visited & (1<<next)) > 0;
+    }
+}

BOJ/1000-5000번/YJ_2660.java

@@ -0,0 +1,90 @@
+import java.util.*;
+import java.io.*;
+
+public class YJ_2660 {
+    static class Node {
+        int index;
+        int distance;
+        Node (int index, int distance) {
+            this.index = index;
+            this.distance = distance;
+        }
+    }
+
+    static List<List<Integer>> graph = new ArrayList<>();
+    static int MAX = 51;    //★무작정 MAX_VALUE 넣지않기
+    static int n;
+
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        n = Integer.parseInt(br.readLine());
+
+        //다익스트라 초기화
+        for(int i=0; i<n+1; i++){
+            graph.add(new ArrayList<>());
+        }
+
+        while(true){
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int to = Integer.parseInt(st.nextToken());
+            int from = Integer.parseInt(st.nextToken());
+            if(to == -1 && from == -1){
+                break;
+            }
+            graph.get(to).add(from);
+            graph.get(from).add(to);
+        }
+
+        getCandidates();
+    }
+
+    static void getCandidates(){
+        int min = MAX;
+        List<Integer> candidates = new ArrayList<>();
+
+        //한 사람에 대한 모든 간선의 연결수 구하기
+        for(int i=1; i<n+1; i++){
+            //회원 별 연결점수 중 최고점을 저장
+            int connection = findConnection(i);
+
+            //회장 후보: 점수가 가장 낮은 사람
+            if(connection < min){
+                candidates = new ArrayList<>();
+                candidates.add(i);
+                min = connection;
+            }else if(connection == min) {
+                candidates.add(i);
+            }
+        }
+
+        System.out.printf("%d %d%n",min,candidates.size());
+        candidates.forEach(candidate -> System.out.printf("%d ",candidate));
+    }
+
+    static int findConnection (int index){
+        PriorityQueue<Node> queue = new PriorityQueue<>((n1,n2) -> n2.distance - n1.distance);
+        queue.offer(new Node(index,0));
+
+        int[] table = new int[n+1];
+        Arrays.fill(table,MAX);
+        table[index] = 0;
+
+        while(!queue.isEmpty()){
+            Node person = queue.poll();
+
+            for(int friend : graph.get(person.index)){
+                if(table[friend] > table[person.index]+1){  //★다음 간선까지의 거리 1
+                    table[friend] = table[person.index]+1;
+                    //★거리를 누적해서 다음 순회에서 친구의 친구 > 친구의 친구의 친구 > ... 연결을 만듬
+                    queue.offer(new Node(friend,table[friend]));    //★Node(연결된 친구,거리)
+                }
+            }
+        }
+
+        int max = 0;
+        for(int i=1; i<n+1; i++){
+            max = Math.max(max,table[i]);
+        }
+        return max;
+    }
+}

BOJ/10001-15000번/YJ_13164.java

@@ -0,0 +1,30 @@
+import java.io.*;
+import java.util.*;
+
+public class YJ_13164 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String[] data = br.readLine().split("\\s");
+        int N = Integer.parseInt(data[0]);
+        int K = Integer.parseInt(data[1]);
+        int[] children = new int[N];
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        for(int i=0; i<N; i++){
+            children[i] = Integer.parseInt(st.nextToken());
+        }
+
+        int[] costs = new int[N-1];
+        for(int i=1; i < children.length; i++){
+            costs[i-1] = children[i] - children[i-1];
+        }
+        Arrays.sort(costs);
+
+        //가장 대소차이가 심한 그룹의 경우 제외하기
+        int total = 0;
+        for(int i=0; i<N-K; i++){
+            total +=  costs[i];
+        }
+        System.out.println(total);
+    }
+}

BOJ/10001-15000번/YJ_14620.java

@@ -0,0 +1,88 @@
+import java.io.*;
+import java.util.*;
+
+public class YJ_14620 {
+    static int N;
+    static int[][] garden;
+    static boolean[][] visited;
+    static int result = 3001;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        N = Integer.parseInt(br.readLine());
+        garden = new int[N][N];
+        visited = new boolean[N][N];
+
+        for(int i=0; i<N; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < N; j++) {
+                garden[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        dfs(0,0);
+        System.out.println(result);
+    }
+
+    static final int SEED = 3;
+    static int[] nx = {0,1,0,-1};
+    static int[] ny = {1,0,-1,0};
+    static void dfs(int depth, int price){
+        if(depth == SEED){
+            result = Math.min(result, price);
+            return;
+        }
+
+        for(int i=1; i<N-1; i++){
+            for(int j=1; j<N-1; j++){
+                if(stop(i,j)){
+                    break;
+                }
+                int flower = plant(i,j);
+                dfs(depth+1,price+flower);
+                remove(i,j);
+            }
+        }
+    }
+
+    //꽃을 심을 수 있는 구간인지 확인
+    static boolean stop(int i, int j){
+        if(visited[i][j]){
+            return true;
+        }
+        for(int d=0; d<4; d++) {
+            int x = i + nx[d];
+            int y = j + ny[d];
+            //꽃을 심을 수 없는 장소
+            if(x < 0 || y < 0 || x >= N || y >= N || visited[x][y]){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    //5평에 꽃 심기
+    static int plant(int i , int j){
+        int price = garden[i][j];
+
+        for(int d=0; d<4; d++) {
+            int x = i + nx[d];
+            int y = j + ny[d];
+            price += garden[x][y];
+            visited[x][y] = true;
+            //System.out.printf("garden[%d][%d] = %d %n",x,y,garden[x][y]);
+        }
+
+        return price;
+    }
+
+    //꽃 하나 없애기
+    static void remove(int i, int j){
+        for(int d=0; d<4; d++) {
+            int x = i + nx[d];
+            int y = j + ny[d];
+            visited[x][y] = false;
+        }
+    }
+
+}

BOJ/20001-25000번/YJ_20007.java

@@ -51,7 +51,6 @@ public static void main(String[] args) throws IOException {
     }
 
     static void shareMochi (int index){
-        int days = 0;
         PriorityQueue<Pos> road = new PriorityQueue<>();
 
         table[index] = 0;