[12주차] 이예진

BOJ/1000-5000번/YJ_2352.java

@@ -0,0 +1,44 @@
+import java.io.*;
+import java.util.*;
+
+public class YJ_2352 {
+    static List<Integer> lis = new ArrayList<>();
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        //초기화
+        int[] connection = new int[n+1];
+        for(int i=1; i<n+1; i++){
+            connection[i] = Integer.parseInt(st.nextToken());
+        }
+
+        lis.add(0);
+        //LIS
+        for(int i = 1; i<connection.length; i++){
+            if(lis.get(lis.size()-1) < connection[i]){
+                lis.add(connection[i]); //최장 증가 원소 추가
+            }else{
+                int index = binarySearch(lis.size()-1, connection[i]);
+                lis.set(index, connection[i]);  //★현재 원소가 들어갈 위치를 찾았다면 현재 원소와 가장 가깝고 큰 원소를 제거
+            }
+        }
+        int result = lis.size()-1;
+        System.out.println(result == 0 ? 1 : result);
+    }
+
+    //타겟이 최장 증가 원소들 중 어느 위치에 들어가면 적절한지 매개변수 탐색
+    public static int binarySearch(int end, int target){
+        int start = 1;
+        while(start < end){
+            int mid = (start + end)/2;  //mid 가 선을 연결할 수 있는지, 없는지
+            if(lis.get(mid) < target){
+                start = mid + 1;    //start 간격을 조정하면 mid 가 커진다 > 더 넓은 범위 에서 연결할 수 있는 선을 찾는다
+            }else{
+                end = mid;  //end 간격을 조정하면 mid 가 작아진다 > 연결을 더 많이 할 수 있다
+            }
+        }
+        return end;
+    }
+    //lower bound: mid 값보다 크거나 같을때 end 는 중간값과 같은 위치에 있음
+}

BOJ/1000-5000번/YJ_2533.java

@@ -0,0 +1,45 @@
+import java.io.*;
+import java.util.*;
+
+public class YJ_2533 {
+    static List<Integer>[] graph;
+    static int[][] dp;  //dp[index][0] : 얼리 아답터 X , dp[index][1] : 얼리 아답터 O
+    static boolean[] visited;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = Integer.parseInt(br.readLine());
+
+        dp = new int[n+1][2];
+        visited = new boolean[n+1];
+        graph = new ArrayList[n+1];
+        for(int i = 1; i < n+1; i++) {
+            graph[i] = new ArrayList<>();
+        }
+        for(int i = 0; i < n-1; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int u = Integer.parseInt(st.nextToken());
+            int v = Integer.parseInt(st.nextToken());
+            graph[u].add(v);
+            graph[v].add(u);
+        }
+
+        dfs(1);
+        System.out.println(Math.min(dp[1][0], dp[1][1]));
+    }
+
+    static void dfs(int u) {
+        visited[u] = true;
+        dp[u][0] = 0;   //얼리 아답터 X
+        dp[u][1] = 1;   //얼리 아답터 O
+
+        for(int i=0; i<graph[u].size(); i++) {
+            if(graph[u].get(i) == null || visited[graph[u].get(i)]) {   //연결된 친구가 없거나, 이미 친구를 방문했다면 패스
+                continue;
+            }
+            dfs(graph[u].get(i));
+            dp[u][0] += dp[graph[u].get(i)][1]; //얼리어답터가 아니라면 나와 연결된 노드는 모두 얼리어답터O
+            dp[u][1] += Math.min(dp[graph[u].get(i)][1],dp[graph[u].get(i)][0]);    //얼리어답터라면 나와 연결된 노드는 얼리어답터O or 얼리어답터X
+        }
+    }
+
+}

BOJ/30000-35000번/YJ_28707.java

@@ -0,0 +1,129 @@
+import java.io.*;
+import java.util.*;
+
+//2 <= N <= 8 으로 조합 경우의 수 8! > 40320개
+//1 <= A <= 10
+public class YJ_28707 {
+    static class Controller {
+        int l;
+        int r;
+        int c;
+
+        public Controller(int l, int r, int c) {
+            this.l = l;
+            this.r = r;
+            this.c = c;
+        }
+    }
+
+    static class Node implements Comparable<Node>{
+        int v;
+        int c;
+
+        public Node(int v, int c) {
+            this.v = v;
+            this.c = c;
+        }
+
+        @Override
+        public int compareTo(Node o){
+            return this.c - o.c;
+        }
+    }
+
+    static int n;
+    static int answer;
+    static List<Controller> list = new ArrayList<>();
+    static Map<Integer,Integer> table = new HashMap<>();    //<배열,최단거리> 저장 테이블
+    static PriorityQueue<Node> pq = new PriorityQueue<>();
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        n = Integer.parseInt(br.readLine());
+
+        //배열 입력값 초기화
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        int[] arr = new int[n];
+        for(int i=0; i<n; i++){
+            arr[i] = Integer.parseInt(st.nextToken());
+            sb.append(arr[i]);
+        }
+
+        //★정렬하는 배열 전체를 하나의 노드 단위로 생각
+        int original = Integer.parseInt(sb.toString());
+        //비내림차순 정렬 정답 저장
+        Arrays.sort(arr);
+        answer = arrToInt(arr);
+
+        //조작 입력값 초기화
+        int m = Integer.parseInt(br.readLine());
+        for(int i=0; i<m; i++){
+            st = new StringTokenizer(br.readLine());
+            int l = Integer.parseInt(st.nextToken())-1;
+            int r = Integer.parseInt(st.nextToken())-1;
+            int c = Integer.parseInt(st.nextToken());
+            list.add(new Controller(l,r,c));
+        }
+
+        table.put(original,0);
+        pq.offer(new Node(original,0));
+        dijkstra();
+        System.out.println(table.getOrDefault(answer,-1));
+    }
+
+    public static void dijkstra(){
+        while(!pq.isEmpty()){
+            Node node = pq.poll();
+            if(answer == node.v){
+                break;
+            }
+            //신규 비용이 기존 비용보다 더 클 경우 갱신불가
+            if(table.containsKey(node.v) && table.get(node.v) < node.c){
+                continue;
+            }
+            for(Controller controller : list){
+                int next = swap(node.v, controller);
+                int cost = node.c + controller.c;
+                if(table.containsKey(next) && table.get(next) <= cost){
+                    continue;
+                }
+                //기존 비용+이동비용 이 기존의 최소 비용보다 더 작을 경우 최단거리(비용) 갱신
+                table.put(next,cost);
+                pq.offer(new Node(next,cost));
+            }
+        }
+    }
+
+    private static int swap(int v, Controller controller){
+        int[] arr = new int[n];
+        for(int i = n - 1; i >= 0; i--) {
+            if(v % 10 == 0){    // 10,20,30.. 등의 두 자릿수 배수가 있다는 뜻 (ex. 1410)
+                arr[i] = v % 100;   //두 자릿수를 배열에 저장
+                v /= 100;
+            } else{   //단일 자릿수일 경우 기존 자릿수 유지
+                arr[i] = v % 10;
+                v /= 10;
+            }
+        }
+
+        //조작에 맞춰서 자리 교체
+        int l = controller.l;
+        int r = controller.r;
+        int temp = arr[l];
+        arr[l] = arr[r];
+        arr[r] = temp;
+
+        return arrToInt(arr);
+    }
+
+    static StringBuilder sb = new StringBuilder();
+    private static int arrToInt(int[] arr) {
+        for(int num : arr){
+            sb.append(num);
+        }
+        int result = Integer.parseInt(sb.toString());
+        sb.setLength(0);
+        return result;
+    }
+}

CodeTree/2019-2020년/YJ_생명과학부_랩_인턴.java

@@ -0,0 +1,131 @@
+import java.io.*;
+import java.util.*;
+
+//2 ≤ n, m ≤ 100 > 10^4
+public class YJ_생명과학부_랩_인턴 {
+    static class Mold {
+        int x;
+        int y;
+        int s;  //이동거리
+        int d;  //이동방향
+        int b;  //곰팡이 크기
+
+        Mold(int x, int y, int s, int d, int b){
+            this.x = x;
+            this.y = y;
+            this.s = calculateS(s,d);
+            this.d = d;
+            this.b = b;
+        }
+
+        private int calculateS(int s, int d){
+            if(d<=1){
+                return s % (2*n-2);
+            }else{
+                return s % (2*m-2);
+            }
+        }
+
+        public void changeD(){
+            //위(0)↔아래(1) , 오른쪽(2)↔왼쪽(3)
+            this.d = this.d%2 == 0? this.d+1 : this.d-1;
+        }
+
+        public boolean isBiggerThan(Mold m){
+            if(Objects.isNull(m)){
+                return true;
+            }
+            return this.b > m.b;
+        }
+    }
+
+    static Mold[][] lab;
+    static List<Mold> inventory = new ArrayList<>();    //인턴이 채취한 곰팡이들
+    static int n;
+    static int m;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        int k = Integer.parseInt(st.nextToken());
+
+        if(k == 0){
+            System.out.println(0);
+        }else{
+            lab = new Mold[n][m];
+            for(int i=0; i<k; i++){
+                st = new StringTokenizer(br.readLine());
+                int x = Integer.parseInt(st.nextToken());
+                int y = Integer.parseInt(st.nextToken());
+                int s = Integer.parseInt(st.nextToken());
+                int d = Integer.parseInt(st.nextToken());
+                int b = Integer.parseInt(st.nextToken());
+                lab[x-1][y-1] = new Mold(x-1,y-1,s,d-1,b);
+            }
+
+            //모든 열 검사
+            for(int i=0; i<m; i++){
+                search(i);
+                moveMolds();
+            }
+            //인턴이 채취한 곰팡이 크기
+            System.out.println(inventory.stream().mapToInt(mold -> mold.b).sum());
+        }
+    }
+
+    //곰팡이 채취하기
+    //열의 위에서 아래로 내려가며 탐색할 때 제일 빨리 발견한 곰팡이를 채취
+    public static void search(int j){
+        for(int i=0; i<n; i++){
+            Mold mold = lab[i][j];
+            if(!Objects.isNull(mold)){
+                inventory.add(mold);
+                lab[i][j] = null;
+                break;
+            }
+        }
+    }
+
+    //곰팡이 이동
+    public static void moveMolds(){
+        Mold[][] tempLab = new Mold[n][m];
+        for(int i=0; i<n; i++){
+            for(int j=0; j<m; j++){
+                Mold mold = lab[i][j];
+                if(Objects.isNull(mold)){
+                    continue;
+                }
+                Mold movedMold = move(mold);    //곰팡이 움직이기
+                //기존 곰팡이보다 더 클 경우 기존 곰팡이 제거
+                if(movedMold.isBiggerThan(tempLab[movedMold.x][movedMold.y])){
+                    tempLab[movedMold.x][movedMold.y] = movedMold;
+                }
+            }
+        }
+        //tempLab > lab 으로 옮기기 : 기존의 lab 에서 곰팡이를 이동시키면 중복 이동이 발생할 수도 있음
+        lab = tempLab;
+    }
+
+    private static Mold move(Mold mold){
+        //위 아래 오른쪽 왼쪽
+        int[] nx = {-1,1,0,0};
+        int[] ny = {0,0,1,-1};
+        //거리만큼 이동
+        int tempS = mold.s;
+        while(tempS-- > 0){
+            int x = mold.x + nx[mold.d];
+            int y = mold.y + ny[mold.d];
+            //격자 범위를 벗어날 경우 방향전환
+            if(x < 0 || y < 0 || x >= n || y >= m){
+                mold.changeD();
+                mold.x = mold.x + nx[mold.d];
+                mold.y = mold.y + ny[mold.d];
+            }else{  //격자 범위 내일 경우 그대로 이동
+                mold.x = x;
+                mold.y = y;
+            }
+        }
+        return mold;
+    }
+}