Merge pull request #22 from yeahdy/main

[2주차] 이예진

Author: baexxbin

BOJ/1000-10000번/YJ_1647.java

@@ -0,0 +1,80 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * 알고리즘: 최소신장트리(MST) > 크루스칼 알고리즘
+ * 시간복잡도: M은 1이상 1,000,000이하이므로 O(NLogN)
+ * 아이디어:
+ * > 최소 신장 트리 조건을 충족하는 문제
+ * - 같은 마을안에서는 집 사이에 경로가 존재하지만, 길을 없앨 수 있다.
+ * - 순환 싸이클이 아니더라도 집끼리 연결만 되어 있으면 됨
+ * - 연결된 경로의 사이는 최소값으로만 연결
+ * 추가 요구사항
+ * - 분리된 두 마을 사이에 있는 길들은 없애도 된다
+ */
+public class YJ_1647 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
+        String[] first = sc.readLine().split("\\s");
+        int N = Integer.parseInt(first[0]);
+        int M = Integer.parseInt(first[1]);
+        int[][] hometown = new int[M][3];
+        for(int i=0; i<M; i++){
+            String[] line = sc.readLine().split("\\s");
+            int[] set = new int[line.length];
+            for(int j=0; j<line.length; j++){
+                set[j] = Integer.parseInt(line[j]);
+            }
+            hometown[i]= set;
+        }
+
+        System.out.println(getMinMaintenance(N, hometown));
+    }
+
+    static int getMinMaintenance(int N,int[][] hometown){
+        int cost = 0;
+        int[] parent = new int[N+1];
+        //자기 자신을 부모로 가지도록 초기값 설정
+        for(int i=1; i<N+1; i++){
+            parent[i] = i;
+        }
+        //유지비 오름차순 정렬 > 유지비가 적은것부터 계산
+        Arrays.sort(hometown, Comparator.comparingInt(o -> o[2]));  //O(NlogN)
+
+        int maxCost = 0;
+        for(int i=0; i<hometown.length; i++){   //O(M)
+            if(find(parent, hometown[i][0]) != find(parent, hometown[i][1])){
+                //최소 유지비 누적
+                cost += hometown[i][2];
+                maxCost= Math.max(maxCost,hometown[i][2]);
+                //집합의 부모가 같도록 병합
+                union(parent,hometown[i][0],hometown[i][1]);
+            }
+        }
+        return cost-maxCost;
+    }
+
+    //집합의 부모 찾기
+    private static int find(int[] parent, int i){
+        if(parent[i] == i){
+            return i;
+        }
+        return find(parent, parent[i]);
+    }
+
+    //집합의 더 작은 부모로 병합하기
+    private static void union(int[] parent, int a, int b){
+        int parentA = find(parent,a);
+        int parentB = find(parent,b);
+        //더 작은 부모의 값을 다른 배열의 부모값으로 변경해서 합치기(배열의 값이 같을 경우 같은 부모)
+        if(parentA > parentB){
+            parent[parentA] = parentB;
+        }else{
+            parent[parentB] = parentA;
+        }
+    }
+
+}

BOJ/1000-10000번/YJ_2631.java

@@ -0,0 +1,44 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 알고리즘: DP > 최장증가 부분수열(Longest Increasing Subsequence)
+ * 시간복잡도: 2 <= N <= 200 이므로 신경쓰지 않아도 됨
+ * 아이디어:
+ * - 어떤 기준으로 정렬을 해야 하는지?
+ * 최소 이동 횟수는 이미 정렬된 수는 제외하고, 나머지 정렬 안된 수들만 움직이기
+ * - 이미 정렬된 수는 제외하는 기준?
+ * 주어진 숫자들에서 오름차순으로 가장 길게 정렬된 수는 이동하지 않아도 됨
+ *- 최장 오름차순 정렬 수 구하는 방법?
+ * 현재 값과 이전 값을 비교해서 이전 값이 더 작을 경우, 현재 정렬수(기본 1) +1 한다 (누적)
+ * 반복을 통해 현재 값과 이전 값들을 비교해서 가장 높은 정렬 수로 현재 값을 갱신한다
+ * 따라서 (전체 숫자 수 - 최장 오름차순 길이)를 한 나머지 개수가 움직여야 하는 갯수가 된다.
+ */
+public class YJ_2631 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int children = Integer.parseInt(br.readLine());
+        int[] line = new int[children];
+        for(int i=0; i<children; i++){
+            line[i] = Integer.parseInt(br.readLine());
+        }
+
+        System.out.println(getMinChanged(children,line));
+    }
+
+    static int getMinChanged(int children,int[] line){
+        int [] dp = new int[children];
+        for(int i=0; i<children; i++){
+            dp[i] = 1;  //최소값 1
+            for(int j=0; j<i; j++){
+                //line의 이전[j] 값들이 현재(i) 값보다 작고,
+                //dp의 이전 값+1이 현재 값보다 클 경우 최장 정렬 수 갱신
+                if(line[j] < line[i] && dp[j]+1 > dp[i]){
+                    dp[i] = dp[j]+1;
+                }
+            }
+        }
+        Arrays.sort(dp);    //오름차순 정렬 시 마지막 수가 최장 정렬 수
+        return children - dp[children-1];
+    }
+}

CodeTree/2017-2018년/YJ_자율주행_자동차.java

@@ -0,0 +1,102 @@
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+/**
+ * 알고리즘: BFS
+ * 시간복잡도:3 ≤ n, m ≤ 50 범위로 BFS 의 O(n)로 가능
+ * 아이디어:
+ * BFS로 순회할 때 요구사항에 맞는 구현을 잘 정리해서 로직을 작성해야함
+ * 1.자동차는 첫 시작을 기준으로 좌회전한다
+ * 2.해당 방향이 방문했거나 인도인 경우 계속 좌회전한다
+ * 3.좌회전 중 도로가 있을 경우 이동한다
+ * 4.만약 4방향 모두 전진이 불가할 경우 바라보는 방향을 유지한 채로 한칸 후진한다
+ * 5.후진한 후 4방향을 탐색한다
+ * 6.후진이 불가하다면 작동을 멈춘다
+ */
+public class YJ_자율주행_자동차 {
+    //자동차 방향: 상-좌-하-우
+    static int[][] direction = {{-1,0}, {0,-1}, {1,0}, {0,1}};
+    static int[][] road = null;
+    static Queue<int[]> queue = new LinkedList<>();
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        String[] firstLine = sc.nextLine().split("\\s");
+        String[] secondLine = sc.nextLine().split("\\s");
+
+        int N = Integer.parseInt(firstLine[0]); //세로
+        int M = Integer.parseInt(firstLine[1]); //가로
+        road = new int[N][M];
+        for (int i = 0; i < N; i++) {  //길 데이터 채우기
+            String[] line = sc.nextLine().split("\\s");
+            for (int j = 0; j < M; j++) {
+                road[i][j] = Integer.parseInt(line[j]);
+            }
+        }
+
+        //자동차 현재위치
+        int X = Integer.parseInt(secondLine[0]);
+        int Y = Integer.parseInt(secondLine[1]);
+        queue.offer(new int[]{X, Y});
+        road[X][Y] = -1;
+
+        int D = Integer.parseInt(secondLine[2]);    //북-동-남-서
+        int result = 1;
+        switch (D) {
+            case 0:
+                result = bfs(0);
+                break;
+            case 1:
+                result = bfs(3);
+                break;
+            case 2:
+                result = bfs(2);
+                break;
+            case 3:
+                result = bfs(1);
+                break;
+        }
+
+        System.out.println(result);
+    }
+
+
+    private static int bfs(int startD) {
+        int visited = 1;
+        while (!queue.isEmpty()) {
+            int[] current = queue.poll();
+            int x = current[0];
+            int y = current[1];
+            int directionIndex = startD;
+
+            for (int i = 0; i < 4; i++) {
+                int nx = x + direction[directionIndex][0];
+                int ny = y + direction[directionIndex][1];
+
+                if (nx >= 0 && nx < road.length && ny >= 0 && ny < road[0].length && road[nx][ny] == 0) {
+                    queue.offer(new int[]{nx, ny});
+                    road[nx][ny] = -1;
+                    visited++;
+                    break;
+                }
+
+                directionIndex = (directionIndex + 1) % 4;
+            }
+
+            // 후진
+            if(queue.isEmpty()){
+                int backX = x - direction[startD][0];
+                int backY = y - direction[startD][1];
+                if (backX >= 0 && backX < road.length && backY >= 0 && backY < road[0].length && road[backX][backY] == 0) {
+                    queue.offer(new int[]{backX, backY});
+                    road[backX][backY] = -1;
+                    visited++;
+                } else {
+                    break;
+                }
+            }
+        }
+        return visited;
+    }
+}

Programmers/Level2/YJ_더_맵게.java

@@ -0,0 +1,41 @@
+import java.util.PriorityQueue;
+
+/**
+ * 알고리즘: 우선순위 큐
+ * 시간복잡도: 2  <= scoville <= 1,000,000 크기로 O(NlogN)
+ * 아이디어:
+ * 두 수를 합친 후 스코빌 배열에서 오름차순 정렬이 되어야 하기 때문에
+ * 우선순위 큐를 사용해서 두수를 빼내고, 합친 수를 다시 넣도록 함
+ * 우선순위 큐는 기본적으로 원소를 오름차순 정렬하기 때문에 큐의 첫번째 원소가 K 보다 크거나 같다면 스코빌 모든 음식의 스코빌 지수가 K 이상 임
+ */
+public class YJ_더_맵게 {
+    public int solution(int[] scoville, int K) {
+        int answer = 0;
+        PriorityQueue<Integer> queue = new PriorityQueue<>();
+        for(int s : scoville){
+            queue.offer(s);
+        }
+
+        while(queue.size() > 1){
+            int first = queue.poll();
+            if(first >= K){
+                break;
+            }
+            int second = queue.poll();
+            int mixed = calculateScoville(first,second);
+            queue.offer(mixed);
+            answer++;
+        }
+
+        if(queue.poll() < K){
+            return -1;
+        } else {
+            return answer;
+        }
+    }
+
+    //첫번째로 낮은 스코빌 지수 + (두번째로 낮은 스코빌 지수 * 2)
+    private int calculateScoville(int first, int second){
+        return first + (second*2);
+    }
+}

Programmers/Level2/YJ_땅따먹기.java

@@ -0,0 +1,33 @@
+/***
+ * 알고리즘: 일반구현
+ * 시간복잡도: N <= 100,000 크기로 O(NlogN)까지 가능
+ * 아이디어:
+ * 요구사항은 이전의 행과 같은 열을 밝지 않고, 각 행의 열의 합이 최고점 찾기
+ * 이전의 행과 현재의 행을 비교하는데, 이전 행의 열들 중 현재 행과 같은 열을 제외하고 최고점을 찾는다
+ */
+public class YJ_땅따먹기 {
+    public static void main(String[] args) {
+        int[][] land ={{1,2,3,5},{5,6,7,8},{4,3,2,1}};
+        int answer = 0;
+
+        // 이전 행의 열들 중 현재 행과 같은 열을 제외하고 최고점 (현재 행의 열: 0 , 이전행의 열: 1,2,3)
+        // 각 행마다 이전 행의 최고점 열을 누적해서 더하기
+        for(int i=1; i<land.length; i++){
+            land[i][0] += maxLand(land[i-1][1],land[i-1][2],land[i-1][3]);
+            land[i][1] += maxLand(land[i-1][0],land[i-1][2],land[i-1][3]);
+            land[i][2] += maxLand(land[i-1][0],land[i-1][1],land[i-1][3]);
+            land[i][3] += maxLand(land[i-1][0],land[i-1][1],land[i-1][2]);
+        }
+
+        // 마지막 행에 모든 행들의 누적 최고점 열이 있음
+        int maxScore = 0;
+        for(int i=0; i<land[0].length; i++){
+            maxScore = Math.max(maxScore,land[land.length-1][i]);
+        }
+        System.out.println(answer);
+    }
+
+    private static int maxLand(int first, int second, int third){
+        return Math.max(Math.max(first,second),third);
+    }
+}

Programmers/Level2/YJ_방문길이.java

@@ -1,3 +1,4 @@
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Queue;
 
@@ -6,19 +7,21 @@
  * 시간복잡도: O(n)
  * 아이디어:
  * BFS로 순회할때 방문한 지점을 방문처리 하는 것이 아닌 다녀간 길을 방문처리 해야 함
- * 다녀간 길을 표시하는 방법?
- * 
+ - 현재 위치(x,y) + 다음 위치(x,y) 를 문자열 형태로 저장
+ > 중복일 경우 이미 다녀간 경로!
+ - 다음 위치(x,y) + 현재 위치(x,y) 를 문자열 형태로 저장
+ > 위아래 또는 좌우 왔다갔다한 경로도 이미 다녀간 경로!
  */
 public class YJ_방문길이 {
     public static void main(String[] args) {
-        String dirs = "ULURRDLLU";  //7
-//        String dirs = "LULLLLLLU";  //7
+//        String dirs = "ULURRDLLU";  //7
+        String dirs = "LULLLLLLU";  //7
         System.out.println(solution(dirs));
     }
 
     static int answer = 0;
     static int[][] direction = {{0,1},{0,-1},{-1,0},{1,0}}; //상,하,좌,우
-    static boolean[][] visited = new boolean[11][11];
+    static HashSet<String> visited = new HashSet<>();
     static Queue<int[]> queue = new LinkedList<>();
     static int solution(String dirs) {
         String[] input = dirs.split("");
@@ -27,43 +30,46 @@ static int solution(String dirs) {
 
         //현재위치 방문처리
         queue.offer(start);
-        visited[start[0]][start[1]] = true;
-
         for(String i : input){
             switch(i){
                 case "U":
-                    bfs(visited,direction[0]);
+                    bfs(end,visited,direction[0]);
                     break;
                 case "D":
-                    bfs(visited,direction[1]);
+                    bfs(end,visited,direction[1]);
                     break;
                 case "L":
-                    bfs(visited,direction[2]);
+                    bfs(end,visited,direction[2]);
                     break;
                 case "R":
-                    bfs(visited,direction[3]);
+                    bfs(end,visited,direction[3]);
                     break;
             }
         }
         return answer;
     }
 
-    private static void bfs(boolean[][] visited, int[] direction){
+    private static void bfs(int[] end, HashSet<String> visited, int[] direction){
         int[] current = queue.peek();
+        int x = current[0];
+        int y = current[1];
         //위치 이동
-        int nx = current[0] + direction[0];
-        int ny = current[1] + direction[1];
+        int nx =  x + direction[0];
+        int ny = y + direction[1];
+        String visitLength = ""+x+y+nx+ny;
+        String reverseLength = ""+nx+ny+x+y;
 
-        if(nx < 0 || nx > visited[0].length -1 || ny < 0 || ny > visited.length-1){
-            return;
-        }
-        if(visited[nx][ny]){
+        if(nx < 0 || nx > end[0]-1 || ny < 0 || ny > end[1]-1){
             return;
         }
         //방문처리
         queue.poll();
-        visited[nx][ny] = true;
-        //이동값 갱신
+
+        if(visited.contains(visitLength) || visited.contains(reverseLength)){
+            queue.offer(new int[]{nx,ny});
+            return;
+        }
+        visited.add(visitLength);
         queue.offer(new int[]{nx,ny});
         answer++;
     }