diff --git a/src/programmers/algorithm/binarySearch/Q64062.java b/src/programmers/algorithm/binarySearch/Q64062.java
new file mode 100644
index 0000000..5e8eba1
--- /dev/null
+++ b/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;
+    }
+}
\ No newline at end of file
diff --git a/src/programmers/algorithm/dp/Q131129.java b/src/programmers/algorithm/dp/Q131129.java
new file mode 100644
index 0000000..e7d75dc
--- /dev/null
+++ b/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];
+    }
+}
\ No newline at end of file
diff --git a/src/programmers/algorithm/greedy/Q12979.java b/src/programmers/algorithm/greedy/Q12979.java
new file mode 100644
index 0000000..e9799ba
--- /dev/null
+++ b/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;
+    }
+}
\ No newline at end of file
diff --git a/src/programmers/algorithm/mst/Q150366.java b/src/programmers/algorithm/mst/Q150366.java
new file mode 100644
index 0000000..a875b99
--- /dev/null
+++ b/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]);
+    }
+}
\ No newline at end of file
diff --git a/src/programmers/algorithm/mst/Q62050.java b/src/programmers/algorithm/mst/Q62050.java
new file mode 100644
index 0000000..6628067
--- /dev/null
+++ b/src/programmers/algorithm/mst/Q62050.java
@@ -0,0 +1,118 @@
+package programmers.algorithm.mst;
+
+import java.util.*;
+
+class Q62050 {
+    static int[][] group;
+    static int[][] Land;
+    static int N;
+    static int H;
+
+    static int[] dRow = {-1,1,0,0};
+    static int[] dCol = {0,0,-1,1};
+
+    static class Edge{
+        int from;
+        int to;
+        int cost;
+
+        Edge(int from, int to, int cost){
+            this.from = from;
+            this.to = to;
+            this.cost = cost;
+        }
+    }
+
+    static int[] parent;
+
+    public int solution(int[][] land, int height) {
+        int answer = 0;
+
+        Land = land;
+        N = land.length;
+        H = height;
+
+        group = new int[N][N];
+
+        // dfs -> 공짜로 이동 가능한 칸끼리 구역 만들기
+        int groupNum = 1;
+        for(int r=0;r<N;r++){
+            for(int c=0;c<N;c++){
+                if(group[r][c] == 0){
+                    dfs(r,c,groupNum);
+                    groupNum++;
+                }
+            }
+        }
+
+        // 서로 다른 구역 맞닿으면 사다리 간선 만들기
+        List<Edge> edges = new ArrayList<>();
+        for(int r=0;r<N;r++){
+            for(int c=0;c<N;c++){
+
+                for(int i=0;i<4;i++){
+                    int nr = r+dRow[i];
+                    int nc = c+dCol[i];
+
+                    if(nr>=0 && nr<N && nc>=0 && nc<N
+                            && (group[r][c] != group[nr][nc])){
+                        int cost = Math.abs(land[r][c] - land[nr][nc]);
+                        edges.add(new Edge(group[r][c],group[nr][nc],cost));
+                    }
+                }
+            }
+        }
+
+        // 사다리 비용 순 정렬
+        edges.sort((a,b) -> a.cost-b.cost);
+
+        // kruskal(union-find)로 싼 사다리부터 연결
+        parent = new int[groupNum];
+        for(int i=1;i<groupNum;i++){
+            parent[i] = i;
+        }
+
+        for(Edge edge: edges){
+            if(union(edge.from,edge.to)){
+                answer += edge.cost;
+            }
+        }
+
+        return answer;
+    }
+
+    static void dfs(int r, int c, int groupNum){
+        group[r][c] = groupNum;
+
+        for(int i=0;i<4;i++){
+            int nr = r+dRow[i];
+            int nc = c+dCol[i];
+
+            if(nr>=0 && nr<N && nc>=0 && nc<N
+                    && group[nr][nc]==0
+                    && Math.abs(Land[r][c] - Land[nr][nc])<=H){
+                dfs(nr,nc,groupNum);
+            }
+        }
+    }
+
+    static int find(int x){
+        if(parent[x] == x){
+            return x;
+        }
+
+        return parent[x] = find(parent[x]);
+    }
+
+    static boolean union(int a, int b){
+        a = find(a);
+        b = find(b);
+
+        // 이미 연결
+        if(a==b){
+            return false;
+        }
+        parent[b] = a;
+        return true;
+    }
+}
\ No newline at end of file