[0905] 131129번 - 카운트 다운, 62050번 - 지형 이동

src/programmers/algorithm/binarySearch/Q64062.java

@@ -0,0 +1,44 @@
+package programmers.algorithm.binarySearch;
+
+class Q64062 {
+    static int K;
+    public int solution(int[] stones, int k) {
+        int answer = 0;
+
+        K = k;
+
+        int left = 0;
+        int right = 200000000;
+        while(left<=right){
+            int mid = left + (right-left)/2;
+            // System.out.println("mid="+mid);
+
+            if(available(stones,mid)){
+                answer = mid;
+                left = mid+1;
+            }
+            else{
+                right = mid-1;
+            }
+        }
+
+        return answer;
+    }
+
+    static boolean available(int[] stones, int friend){
+        int count = 0;
+        for(int i=0;i<stones.length;i++){
+            if(stones[i]-friend < 0){
+                count++;
+            }
+            else{
+                count = 0;
+            }
+            if(count >= K){
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

src/programmers/algorithm/dp/Q131129.java

@@ -0,0 +1,60 @@
+package programmers.algorithm.dp;
+
+class Q131129 {
+    public int[] solution(int target) {
+        int[] answer = {};
+
+        int[][] dp = new int[target+1][2];
+        for(int i=0;i<=target;i++){
+            dp[i][0] = Integer.MAX_VALUE;
+            dp[i][1] = 0;
+        }
+
+        dp[0][0] = 0;
+        for(int i=1;i<=target;i++){
+            for(int j=1;j<=20;j++){
+                // 불
+                if(i-50>=0){
+                    if(dp[i][0] > dp[i-50][0]+1){
+                        dp[i][0] = dp[i-50][0]+1;
+                        dp[i][1] = dp[i-50][1]+1;
+                    }
+
+                    else if(dp[i][0] == dp[i-50][0]+1){
+                        dp[i][1] = Math.max(dp[i][1],dp[i-50][1]+1);
+                    }
+                }
+
+                // 싱글
+                if(i-j>=0){
+                    if(dp[i][0] > dp[i-j][0]+1){
+                        dp[i][0] = dp[i-j][0]+1;
+                        dp[i][1] = dp[i-j][1]+1;
+                    }
+                    else if(dp[i][0] == dp[i-j][0]+1){
+                        dp[i][1] = Math.max(dp[i][1],dp[i-j][1]+1);
+                    }
+                }
+
+                // 더블
+                if(i-2*j>=0){
+                    if(dp[i][0] > dp[i-2*j][0]+1){
+                        dp[i][0] = dp[i-2*j][0]+1;
+                        dp[i][1] = dp[i-2*j][1];
+                    }
+                }
+
+                // 트리플
+                if(i-3*j>=0){
+                    if(dp[i][0] > dp[i-3*j][0]+1){
+                        dp[i][0] = dp[i-3*j][0]+1;
+                        dp[i][1] = dp[i-3*j][1];
+                    }
+                }
+            }
+
+        }
+
+        return dp[target];
+    }
+}

src/programmers/algorithm/greedy/Q12979.java

@@ -0,0 +1,42 @@
+package programmers.algorithm.greedy;
+
+class Q12979 {
+    public int solution(int n, int[] stations, int w) {
+        int answer = 0;
+
+        int wdis = 2*w+1;
+
+        int left = 1;
+        int right = 0;
+        int count = 0;
+        for(int station: stations){
+            right = station-w-1;
+
+            int dis = right-left+1;
+            if(dis>=1){
+                if(dis%wdis == 0){
+                    count += dis/wdis;
+                }
+                else{
+                    count += dis/wdis+1;
+                }
+            }
+            // System.out.println("station="+station+" left="+left+" right="+right+" dis="+dis+" count="+count);
+            left = station+w+1;
+        }
+
+        right = n;
+        int dis = right-left+1;
+        if(dis>=1){
+            if(dis%wdis == 0){
+                count += dis/wdis;
+            }
+            else{
+                count += dis/wdis+1;
+            }
+        }
+
+        // System.out.println(" left="+left+" right="+right+" dis="+dis+" count="+count);
+        return count;
+    }
+}

src/programmers/algorithm/mst/Q150366.java

@@ -0,0 +1,128 @@
+package programmers.algorithm.mst;
+
+import java.util.*;
+
+class Q150366 {
+    static int[] parent;
+    public String[] solution(String[] commands) {
+        List<String> answer = new ArrayList<>();
+
+        String[] table = new String[2500];
+        Map<String,Integer> map = new HashMap<>();
+
+        parent = new int[2500];
+        for(int i=0;i<2500;i++){
+            parent[i] = i;
+        }
+
+        for(int i=0;i<commands.length;i++){
+            String command = commands[i];
+
+            String[] tokens = command.split(" ");
+            String action = tokens[0];
+
+            if(action.equals("UPDATE")){
+                if(tokens.length == 4){
+                    int r = Integer.parseInt(tokens[1]);
+                    int c = Integer.parseInt(tokens[2]);
+                    String value = tokens[3];
+
+                    int num = (r-1)*50+(c-1);
+
+                    int root = find(num);
+
+                    table[root] = value;
+                }
+
+                else{
+                    String value1 = tokens[1];
+                    String value2 = tokens[2];
+
+                    for(int j=0;j<2500;j++){
+                        if(value1.equals(table[j])){
+                            table[j] = value2;
+                        }
+                    }
+                }
+            }
+
+            else if(action.equals("MERGE")){
+                int r1 = Integer.parseInt(tokens[1]);
+                int c1 = Integer.parseInt(tokens[2]);
+                int r2 = Integer.parseInt(tokens[3]);
+                int c2 = Integer.parseInt(tokens[4]);
+
+                int num1 = (r1-1)*50+(c1-1);
+                int num2 = (r2-1)*50+(c2-1);
+
+                int root1 = find(num1);
+                int root2 = find(num2);
+
+                if(root1 != root2){
+                    String value;
+
+                    if(table[root1] != null){
+                        value = table[root1];
+                    }
+                    else{
+                        value = table[root2];
+                    }
+
+                    parent[root2] = root1;
+                    table[root1] = value;
+                    table[root2] = null;
+                }
+            }
+
+            else if(action.equals("UNMERGE")){
+                int r = Integer.parseInt(tokens[1]);
+                int c = Integer.parseInt(tokens[2]);
+
+                int num = (r-1)*50+(c-1);
+
+                int root = find(num);
+
+                String value = table[root];
+
+                List<Integer> group = new ArrayList<>();
+                for(int j=0;j<2500;j++){
+                    if(find(j) == root){
+                        group.add(j);
+                    }
+                }
+                for(int x: group){
+                    parent[x] = x;
+                    table[x] = null;
+                }
+
+                table[num] = value;
+            }
+
+            else{
+                int r = Integer.parseInt(tokens[1]);
+                int c = Integer.parseInt(tokens[2]);
+
+                int num = (r-1)*50+(c-1);
+
+                int root = find(num);
+
+                if(table[root] == null){
+                    answer.add("EMPTY");
+                }
+                else{
+                    answer.add(table[root]);
+                }
+            }
+        }
+
+        return answer.toArray(new String[0]);
+    }
+
+    static int find(int x){
+        if(parent[x] == x){
+            return x;
+        }
+
+        return parent[x]=find(parent[x]);
+    }
+}