diff --git a/week17/Baekjoon1516.java b/week17/Baekjoon1516.java
index e078aef..fef929a 100644
--- a/week17/Baekjoon1516.java
+++ b/week17/Baekjoon1516.java
@@ -1,3 +1,53 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 25/06/16
+ * Java8 | 실행시간: 160 ms, 메모리 : 17,424KB
+ */
 public class Baekjoon1516 {
+	
+	public static void main(String[] args) throws IOException {
+        int N = readInt();
+
+        int[] inDegree = new int[N+1];
+        int[] cost = new int[N+1];
+        int[] result = new int[N+1];
+        ArrayList<ArrayList<Integer>> arr = new ArrayList<>();
+        for (int i=0;i<=N;i++) arr.add(new ArrayList<>());
+        Queue<Integer> q = new ArrayDeque<>();
+
+        for (int v=1;v<=N;v++){
+            cost[v] = readInt();
+            int u = 0;
+            while((u=readInt())!=-1){
+                arr.get(u).add(v);
+                inDegree[v]++;
+            }
+        }
+
+        for (int i=1;i<=N;i++) {
+            if (inDegree[i]==0){
+                q.offer(i);
+                result[i] = cost[i];
+            }
+        }
+
+        while(!q.isEmpty()){
+            int c = q.poll();
+            for (int nextPoint : arr.get(c)){
+                result[nextPoint] = Math.max(result[nextPoint], result[c]+cost[nextPoint]);
+                if (--inDegree[nextPoint]==0) q.offer(nextPoint);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i=1;i<=N;i++) sb.append(result[i]).append("\n");
+        System.out.print(sb);
+    }
 
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
 }
diff --git a/week17/Baekjoon17182.java b/week17/Baekjoon17182.java
index 8b41251..94213a4 100644
--- a/week17/Baekjoon17182.java
+++ b/week17/Baekjoon17182.java
@@ -1,3 +1,48 @@
+import java.io.*;
+/**
+ * 250616
+ * Java8 | 실행시간: 96 ms, 메모리: 11,912KB
+ */
 public class Baekjoon17182 {
 
+    static int N, dt[][], result = Integer.MAX_VALUE;
+    static boolean[] isVisited;
+
+    public static void main(String[] args) throws IOException {
+        // 모든 행성을 탐사하기 위한 최소 시간 출력
+        // 다시 시작 행성으로 돌아올 필요 X, 중복 방문 가능
+        N = readInt();
+        int K = readInt();  // 0<=K<N
+        dt = new int[N][N];
+        for (int i=0;i<N;i++) for(int j=0;j<N;j++) dt[i][j] = readInt();
+        
+        for (int k=0;k<N;k++) for (int i=0;i<N;i++) for (int j=0;j<N;j++){
+            dt[i][j] = Math.min(dt[i][j], dt[i][k]+dt[k][j]);
+        }
+
+        isVisited = new boolean[N];
+        isVisited[K] = true;
+        System.out.print(recursive(K, 0, dt[K][K]));
+    }
+
+    private static int recursive(int v, int ct, int sum){
+        if (sum>=result) return result;   // 가지치기
+        if (ct==N-1) return sum;
+
+        for (int i=0;i<N;i++){
+            if (!isVisited[i]){
+                isVisited[i] = true;
+                result = Math.min(result, recursive(i, ct+1, sum+dt[v][i]));
+                isVisited[i] = false;
+            }
+        }
+        return result;
+    }
+
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
+
 }
diff --git a/week17/Baekjoon21939.java b/week17/Baekjoon21939.java
index c6dcba5..a9f61ae 100644
--- a/week17/Baekjoon21939.java
+++ b/week17/Baekjoon21939.java
@@ -1,3 +1,71 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 250615
+ * Java8 | 실행시간: 372 ms, 메모리 : 31,748 KB
+ */
+
 public class Baekjoon21939 {
+	private static class Node implements Comparable<Node>{
+        int P, L;
+        Node(int P, int L){
+            this.P = P; // 문제번호
+            this.L = L; // 문제난이도
+        }
+
+        @Override
+        public int compareTo(Node o) {
+            return (this.L!=o.L) ? Integer.compare(this.L, o.L) : Integer.compare(this.P, o.P);
+        }
+    }
+    private static TreeSet<Node> list = new TreeSet<Node>();
+    private static HashMap<Integer, Integer> P2L = new HashMap<>(); // 문제번호 -> 난이도 조회
+
+    public static void main(String[] args) throws IOException {
+        int N = readInt(); // 문제 개수
+        for (int i=0;i<N;i++) add(readInt(), readInt());
+    
+        int M = readInt(); // 명령문 개수
+        StringBuilder sb = new StringBuilder();
+        for (int i=0;i<M;i++){
+            switch (readString()){
+                case "add":
+                    add(readInt(), readInt());
+                    break;
+                case "recommend":
+                    sb.append(select(readInt())).append("\n");
+                    break;
+                case "solved":
+                    delete(readInt());
+                    break;
+            }
+        }
+        System.out.print(sb);
+    }
+
+    private static void add(int P, int L){ // 추가 연산
+        list.add(new Node(P, L));
+        P2L.put(P, L);
+    }
+
+    private static int select(int x){ // 조회 연산
+        if (x==1) return list.last().P;
+        return list.first().P;
+    }
 
+    private static void delete(int P){ // 제거 연산
+        list.remove(new Node(P, P2L.get(P)));
+        P2L.remove(P);
+    }
+    
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken(); // 1<=N,P<=100_000 / 1<=M<=10_000 / 1<=L<=100 / |x|=1
+        return (int) st.nval;
+    }
+    private static String readString() throws IOException{
+        st.nextToken();
+        return st.sval;
+    }
 }
diff --git a/week17/Baekjoon2357.java b/week17/Baekjoon2357.java
index bb42cf6..72e29ae 100644
--- a/week17/Baekjoon2357.java
+++ b/week17/Baekjoon2357.java
@@ -1,3 +1,99 @@
+// Node(min, max) 로 하나의 트리에 최댓값/최솟값 모두 저장하던 구조 -> minTree, maxTree 로 분리
+// 분리했을 때 메모리(32,552 KB) / 이전 구조 메모리(36,716 KB)
+
+// 추가적으로 세그먼트 트리 크기 구할 때, while 문으로 start 인덱스 구하는 거 말고 (2^start>=N) 식 활용해서 수식으로 구하는 것도 해봤는데 별 효과 없어서 제거함
+// 결국 while 로 구해도 O(logN) 이라서 크게 효과 없는 듯
+
+/**
+ * 250617듯
+ * Java8 | 실행시간: 372 ms, 메모리: 32552 KB
+ */
+import java.io.*;
+
 public class Baekjoon2357 {
+	
+    private static class SegTree{
+        int size, start;
+        int[] minTree;
+        int[] maxTree;
+
+        SegTree(int n){
+            size = n;
+            start = 1;
+
+            while(start < size) start <<= 1;
+            minTree = new int[start*2];
+            maxTree = new int[start*2];
+        }
+        
+        // 선입력 받은 리프 노드로 전체 세그먼트 트리 구성
+        // 하나의 공간은 그 구간의 최솟값, 최댓값을 가지고 있음
+        void construct(){
+            for (int i=start-1; i>0; i--) {
+                minTree[i] = Math.min(minTree[i*2], minTree[i*2+1]);
+                maxTree[i] = Math.max(maxTree[i*2], maxTree[i*2+1]);
+            }
+        }
+        
+        // [a, b] 구간의 최댓값, 최솟값 조회
+        Node getMinMax(int a, int b){
+            a += start;
+            b += start;
+            int min = Integer.MAX_VALUE;
+            int max = Integer.MIN_VALUE;
+
+            while (a <= b){ // a 와 b 가 겹칠 때까지 왼쪽/오른쪽에서 가운데로 좁혀오도록 이동 (최고 높이의 공통 부모 노드까지 이동)
+                // 구간을 쪼갰을 때 양쪽 경계에 걸쳐 있는 예외 노드를 따로 챙겨주자
+                if ((a&1)==1){ // (1) a가 부모 노드의 오른쪽 노드일 때
+                    min = Math.min(min, minTree[a]);
+                    max = Math.max(max, maxTree[a]);
+                    a++;
+                }
+                if ((b&1)==0){ // (2) b가 부모 노드의 왼쪽 노드일 때
+                    min = Math.min(min, minTree[b]);
+                    max = Math.max(max, maxTree[b]);
+                    b--;
+                }
+                a >>= 1; // 다음 부모 노드로 올라감
+                b >>= 1;
+            }
+            return new Node(min, max);
+        }
+    }
+
+    private static class Node{
+        int min, max;
+        Node(int min, int max){
+            this.min = min;
+            this.max = max;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        int N = readInt();
+        int M = readInt(); // 쿼리 개수
+
+        SegTree st = new SegTree(N);
+
+        for (int i=0;i<N;i++){
+            st.minTree[st.start + i] = st.maxTree[st.start + i] = readInt();    // 리프노드 입력
+        }
+        st.construct(); // 전체 세그먼트 트리 구성
 
+        StringBuilder sb = new StringBuilder();
+        for (int i=0;i<M;i++){
+            int a = readInt();
+            int b = readInt();
+            Node res = st.getMinMax(a-1, b-1);
+            sb.append(res.min).append(" ").append(res.max).append("\n");
+        }
+        System.out.print(sb);
+    }
+    
+    // 입력 로직
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
 }
diff --git "a/week17/Baekjoon2357_\355\212\270\353\246\2541\352\260\234\354\202\254\354\232\251.java" "b/week17/Baekjoon2357_\355\212\270\353\246\2541\352\260\234\354\202\254\354\232\251.java"
new file mode 100644
index 0000000..7241d7d
--- /dev/null
+++ "b/week17/Baekjoon2357_\355\212\270\353\246\2541\352\260\234\354\202\254\354\232\251.java"
@@ -0,0 +1,98 @@
+// 트리 분리하는 게 메모리 성능 더 좋음
+import java.io.*;
+import java.util.*;
+
+/*
+ * Java8 | 실행시간: 384 ms, 메모리: 36716 KB
+ */
+public class Baekjoon2357 {
+
+    private static class SegTree{
+        int size, start;
+        Node[] arr;
+
+        SegTree(int n){
+            size = n;
+            start = 1;
+
+            while(start < size) start <<= 1;
+            arr = new Node[start * 2];
+
+            for (int i=0; i<start*2; i++) arr[i] = new Node();
+        }
+        
+        // 선입력 받은 리프 노드로 전체 세그먼트 트리 구성
+        // 하나의 공간은 그 구간의 최솟값, 최댓값을 가지고 있음
+        void construct(){
+            for (int i=start-1; i>0; i--) {
+                arr[i].min = Math.min(arr[i*2].min, arr[i*2+1].min);
+                arr[i].max = Math.max(arr[i*2].max, arr[i*2+1].max);
+            }
+        }
+        
+        // [a, b] 구간의 최댓값, 최솟값 조회
+        Node getMinMax(int a, int b){
+            a += start;
+            b += start;
+            int min = Integer.MAX_VALUE;
+            int max = Integer.MIN_VALUE;
+
+            while (a <= b){ // a 와 b 가 겹칠 때까지 왼쪽/오른쪽에서 가운데로 좁혀오도록 이동 (최고 높이의 공통 부모 노드까지 이동)
+                // 구간을 쪼갰을 때 양쪽 경계에 걸쳐 있는 예외 노드를 따로 챙겨주자
+                if ((a&1)==1){ // (1) a가 부모 노드의 오른쪽 노드일 때
+                    min = Math.min(min, arr[a].min);
+                    max = Math.max(max, arr[a].max);
+                    a++;
+                }
+                if ((b&1)==0){ // (2) b가 부모 노드의 왼쪽 노드일 때
+                    min = Math.min(min, arr[b].min);
+                    max = Math.max(max, arr[b].max);
+                    b--;
+                }
+                a >>= 1; // 다음 부모 노드로 올라감
+                b >>= 1;
+            }
+            return new Node(min, max);
+        }
+    }
+
+    private static class Node{
+        int min, max;
+        Node(){
+            min = Integer.MAX_VALUE;
+            max = Integer.MIN_VALUE;
+        }
+        Node(int min, int max){
+            this.min = min;
+            this.max = max;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        int N = readInt();
+        int M = readInt(); // 쿼리 개수
+
+        SegTree st = new SegTree(N);
+
+        for (int i=0;i<N;i++){
+            st.arr[st.start + i].min = st.arr[st.start + i].max = readInt();    // 리프노드 입력
+        }
+        st.construct(); // 전체 세그먼트 트리 구성
+
+        StringBuilder sb = new StringBuilder();
+        for (int i=0;i<M;i++){
+            int a = readInt();
+            int b = readInt();
+            Node res = st.getMinMax(a-1, b-1);
+            sb.append(res.min).append(" ").append(res.max).append("\n");
+        }
+        System.out.print(sb);
+    }
+    
+    // 입력 로직
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
+}
diff --git a/week17/Baekjoon2812.java b/week17/Baekjoon2812.java
index 43a8f4f..cff1e75 100644
--- a/week17/Baekjoon2812.java
+++ b/week17/Baekjoon2812.java
@@ -1,3 +1,32 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 250616
+ * Java11 | 실행시간: 280 ms, 메모리: 24,304 KB
+ */
 public class Baekjoon2812 {
 
+    public static void main(String[] args) throws IOException {
+        final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken());
+        int K = Integer.parseInt(st.nextToken());
+
+        String numStr = br.readLine();
+        ArrayDeque<Character> stack = new ArrayDeque<>();
+        for (int i=0;i<N;i++){
+            char nChar = numStr.charAt(i);
+            while(!stack.isEmpty() && K>0 && stack.peekLast()<nChar){
+                stack.pollLast();
+                K--;
+            }
+            stack.offerLast(nChar);
+        }
+
+        while(K-- > 0) stack.pollLast();
+        StringBuilder sb = new StringBuilder();
+        for (char s : stack) sb.append(s);
+        System.out.print(sb);
+    }
 }
diff --git a/week18/Baekjoon_17619.java b/week18/Baekjoon_17619.java
new file mode 100644
index 0000000..76ae6f2
--- /dev/null
+++ b/week18/Baekjoon_17619.java
@@ -0,0 +1,63 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 25240 KB, 456 ms
+ */
+
+public class Main {
+
+    private static class Log implements Comparable<Log>{
+        int x1, x2, y, idx;
+        Log(int x1, int x2, int y, int idx){
+            this.x1 = x1;
+            this.x2 = x2;
+            this.y = y;
+            this.idx = idx;
+        }
+
+        @Override
+        public int compareTo(Log o) {
+            return Integer.compare(this.x1, o.x1);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        int N = readInt(); // 통나무 개수
+        int Q = readInt(); // 질문 개수
+
+        Log[] logs = new Log[N];
+        for (int i=0;i<N;i++){
+            logs[i] = new Log(readInt(), readInt(), readInt(), i);
+        }
+        Arrays.sort(logs);
+
+        int right = 0;
+        int group = 0;
+        int[] groupNum = new int[N];
+
+        for (int i=0;i<N;i++){
+            Log c = logs[i];
+            if (c.x1 <= right) right = Math.max(right, c.x2);
+            else {
+                group++;
+                right = c.x2;
+            }
+            groupNum[c.idx] = group;
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (int i=0;i<Q;i++){
+            int a = readInt() - 1;
+            int b = readInt() - 1;
+            sb.append(groupNum[a]==groupNum[b] ? 1 : 0).append("\n");
+        }
+        System.out.print(sb);
+    }
+
+    private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
+}
diff --git a/week18/Baekjoon_2011.java b/week18/Baekjoon_2011.java
new file mode 100644
index 0000000..db77a48
--- /dev/null
+++ b/week18/Baekjoon_2011.java
@@ -0,0 +1,40 @@
+import java.io.*;
+import java.util.stream.Stream;
+/**
+ * 11520 KB, 68 ms
+ */
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+
+        String num = br.readLine();
+        System.out.print(solution(num));
+    }
+
+    private static final int MOD = 1_000_000;
+    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    private static int solution(String num){
+        int n = num.length();
+
+        if (num.charAt(0)=='0') return 0; // 해석 불가
+
+        int[] dp = new int[n+1];
+        dp[0] = dp[1] = 1;
+        // dp[a] = b : a번째 글자까지 해석할 수 있는 가짓수 = b가지
+        // dp[0]: 빈 문자열 1가지, dp[1]: 첫 글자가 0이 아닌 경우 1가지
+
+        for (int i=2;i<=n;i++){
+            // 한 자리
+            int one = num.charAt(i-1) - '0';
+            if (one>0) dp[i] = (dp[i] + dp[i-1]) % MOD;
+
+            // 두자리
+            int ten = (num.charAt(i-2) - '0') * 10 + one;
+            if (10<=ten && ten<=26) dp[i] = (dp[i] + dp[i-2]) % MOD;
+        }
+
+        return dp[n];
+    }
+}
diff --git a/week18/Baekjoon_2170.java b/week18/Baekjoon_2170.java
new file mode 100644
index 0000000..f23caea
--- /dev/null
+++ b/week18/Baekjoon_2170.java
@@ -0,0 +1,55 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 52712 KB, 1120 ms
+ */
+
+public class Main {
+
+    private static class Line implements Comparable<Line>{
+        int start, end;
+
+        public Line(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        @Override
+        public int compareTo(Line o) {
+            return Integer.compare(this.start, o.start);
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        int N = readInt();
+        PriorityQueue<Line> pq = new PriorityQueue<>();
+
+        for (int i=0;i<N;i++){
+            pq.offer(new Line(readInt(), readInt()));
+        }
+
+        int end = Integer.MIN_VALUE;
+        int result = 0;
+
+        while(!pq.isEmpty()){
+            Line cur = pq.poll();
+            if (cur.start < end && cur.end > end){
+                result += cur.end - end;
+                end = cur.end;
+            } else if (cur.start >= end){
+                result += cur.end - cur.start;
+                end = cur.end;
+            }
+        }
+
+        System.out.print(result);
+
+    }
+
+    private static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
+    private static int readInt() throws IOException{
+        st.nextToken();
+        return (int) st.nval;
+    }
+}
diff --git a/week20/Baekjoon1464.java b/week20/Baekjoon1464.java
index e078aef..570f585 100644
--- a/week20/Baekjoon1464.java
+++ b/week20/Baekjoon1464.java
@@ -1,3 +1,27 @@
-public class Baekjoon1516 {
+package m07.d12;
+
+/**
+ * JAVA8 ) 메모리: 11_608 KB, 시간: 60ms
+ */
+
+import java.io.*;
+import java.util.*;
+
+public class Main_1464_뒤집기3 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String S = br.readLine();
+        ArrayDeque<Character> q = new ArrayDeque<>();
+        q.offer(S.charAt(0));
+        for (int i=1;i<S.length();i++){
+            char s = S.charAt(i);
+            if (s <= q.getFirst()) q.offerFirst(s);
+            else q.offerLast(s);
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char s : q) sb.append(s);
+        System.out.print(sb);
+    }
 
 }
diff --git a/week20/Baekjoon4179.java b/week20/Baekjoon4179.java
index e078aef..68aa89b 100644
--- a/week20/Baekjoon4179.java
+++ b/week20/Baekjoon4179.java
@@ -1,3 +1,90 @@
-public class Baekjoon1516 {
+package m07.d12;
 
+/**
+ * JAVA8) 메모리: 46_648 KB, 시간: 396ms
+ */
+
+import java.io.*;
+import java.util.*;
+
+public class Main_4179_불 {
+
+    private static char[][] map;
+    private static Queue<int[]> people, fire;
+    private static boolean[][] isVisited; // 사람 방문여부
+    private static int R, C, time = 1;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        R = Integer.parseInt(st.nextToken());
+        C = Integer.parseInt(st.nextToken());
+
+        map = new char[R][C];
+        isVisited = new boolean[R][C];
+        people = new ArrayDeque<>();
+        fire = new ArrayDeque<>();
+
+        for (int i=0;i<R;i++) {
+            String s = br.readLine();
+            for (int j=0;j<C;j++) {
+                switch (map[i][j] = s.charAt(j)){
+                    case 'J':
+                        people.offer(new int[]{i, j});
+                        isVisited[i][j] = true;
+                        break;
+                    case 'F':
+                        fire.offer(new int[]{i, j});
+                        break;
+                }
+            }
+        }
+
+        System.out.print(bfs() ? time : "IMPOSSIBLE");
+    }
+
+    private static final int[] dx = {0, 0, 1, -1};
+    private static final int[] dy = {1, -1, 0, 0};
+
+    private static boolean bfs(){
+
+        while (!people.isEmpty()){
+            int ps = people.size();
+            int fs = fire.size();
+
+            // 불 이동
+            while (fs-->0){
+                int[] cur = fire.poll();
+                for (int i=0;i<4;i++){
+                    int nx = cur[0] + dx[i];
+                    int ny = cur[1] + dy[i];
+                    if (nx<0||ny<0||nx>=R||ny>=C) continue;
+                    if (map[nx][ny]=='F'||map[nx][ny]=='#') continue;
+
+                    map[nx][ny] = 'F';
+                    fire.offer(new int[]{nx, ny});
+                }
+            }
+
+            // 사람 이동
+            while (ps-->0){
+                int[] cur = people.poll();
+
+                for (int i=0;i<4;i++){
+                    int nx = cur[0] + dx[i];
+                    int ny = cur[1] + dy[i];
+                    if (nx<0||ny<0||nx>=R||ny>=C) return true;
+                    if (map[nx][ny]=='F'||map[nx][ny]=='#') continue;
+                    if (isVisited[nx][ny]) continue;
+
+                    isVisited[nx][ny] = true;
+                    people.offer(new int[]{nx, ny});
+                }
+            }
+
+            time++;
+        }
+
+        return false;
+    }
 }