diff --git "a/BOJ/1000-5000\353\262\210/YJ_1967.java" "b/BOJ/1000-5000\353\262\210/YJ_1967.java"
new file mode 100644
index 00000000..538717fa
--- /dev/null
+++ "b/BOJ/1000-5000\353\262\210/YJ_1967.java"
@@ -0,0 +1,86 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 알고리즘: DFS
+ * 시간복잡도: 1 ≤ n ≤ 10,000
+ * 아이디어:
+ * 트리에 존재하는 모든 경로들 중에서 가장 긴 것의 길이 구하기
+ * DFS 1번: 루트에서 가장 멀리 있는 노드 탐색 (루트는 항상 존재하기 때문에 루트에서 시작)
+ * DFS 2번: 해당 노드에서 가장 먼 노드 탐색 > 가장 긴 길이 계산
+ */
+
+class Node {
+    int node;
+    int weight;
+
+    public Node(int node, int weight) {
+        this.node = node;
+        this.weight = weight;
+    }
+}
+
+public class YJ_1967 {
+    static List<Node>[] TREE = null;
+    static boolean[] VISITED = null;
+    static int FAR_NODE = 0;
+    static int longLength = 0;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+        VISITED = new boolean[N+1];
+
+        //List index 가 하나의 노드 단위
+        TREE = new ArrayList[N+1];
+        for(int i=1; i<N+1; i++){
+            TREE[i] = new ArrayList<>();
+        }
+
+        //트리 생성
+        for(int i=1; i<N; i++){
+            String[] line = br.readLine().split("\\s");
+            int parent = Integer.parseInt(line[0]);
+            int child = Integer.parseInt(line[1]);
+            int weight = Integer.parseInt(line[2]);
+
+            TREE[parent].add(new Node(child,weight));   //★무방향 (자식 노드로 계속 깊게 탐색)
+            TREE[child].add(new Node(parent,weight));   //★양방향 (자식 노드에서 부모노드를 타고 다시 위로 올라오면 탐색)
+        }
+        //루트부터 시작하므로 방문처리
+        int root = 1;
+        VISITED[root] = true;
+
+        //1.루트에서 가장 멀리 있는 노드 탐색
+        dfs(root,0);
+
+        //2.해당 노드에서 가장 먼 노드 탐색
+        VISITED = new boolean[N+1];
+        VISITED[FAR_NODE] = true;
+        dfs(FAR_NODE,0);
+
+        System.out.println(longLength);
+        br.close();
+    }
+
+    private static void dfs(int start, int sum){
+        longLength = Math.max(sum,longLength);
+        if(sum == longLength){
+            FAR_NODE = start;
+        }
+
+        for(Node data : TREE[start]){
+            int node = data.node;
+            int weight = data.weight;
+
+            if(!VISITED[node]){
+                VISITED[node] = true;
+                dfs(node,sum+weight);
+                VISITED[node] = false;
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git "a/BOJ/5001-10000\353\262\210/YJ_9205.java" "b/BOJ/5001-10000\353\262\210/YJ_9205.java"
new file mode 100644
index 00000000..4d7d56ce
--- /dev/null
+++ "b/BOJ/5001-10000\353\262\210/YJ_9205.java"
@@ -0,0 +1,81 @@
+package BOJ;
+
+import java.io.*;
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * 알고리즘: BFS
+ * 시간복잡도:
+ * 테스트 케이스 t ≤ 50 , 편의점 갯수 0 ≤ n ≤ 100
+ * 모든 지점 간의 거리 계산 시 N * (N-1) = O(N^2) > 50 * (100^2) = 50 * 10000 = 500,000 > 10^5 으로 BFS 풀이가능
+ * */
+public class YJ_9205 {
+    static class Pos {
+        int x;
+        int y;
+        Pos(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    static Deque<Pos> DEQUE;
+    static int[][] CONVINI;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(br.readLine());
+
+        for(int i=0; i<t; i++){
+            int conviniCount = Integer.parseInt(br.readLine());
+
+            //집
+            String[] home = br.readLine().split("\\s");
+            DEQUE = new ArrayDeque<>();
+            DEQUE.offer(new Pos(Integer.parseInt(home[0]), Integer.parseInt(home[1])));
+            //편의점
+            CONVINI = new int[conviniCount][2];
+            for(int j=0; j<conviniCount; j++){
+                String[] c = br.readLine().split("\\s");
+                CONVINI[j][0] = Integer.parseInt(c[0]);
+                CONVINI[j][1] = Integer.parseInt(c[1]);
+            }
+            //페스티벌
+            String[] f = br.readLine().split("\\s");
+            Pos festival = new Pos(Integer.parseInt(f[0]), Integer.parseInt(f[1]));
+
+            bfs(conviniCount, festival);
+        }
+        br.close();
+    }
+
+    static void bfs(int conviniCount, Pos festival){
+        final int STAMINA = 1000;
+        boolean[] visited = new boolean[conviniCount];
+
+        while(!DEQUE.isEmpty()){
+            Pos current = DEQUE.poll();
+            if(calculateDistance(current,festival) <= STAMINA){
+                System.out.println("happy");
+                return;
+            }
+
+            for(int i=0; i<conviniCount; i++){
+                if(visited[i]){
+                    continue;
+                }
+                Pos nextConvini = new Pos(CONVINI[i][0],CONVINI[i][1]);
+                if(calculateDistance(current,nextConvini) <= STAMINA){
+                    DEQUE.offer(nextConvini);
+                    visited[i] = true;
+                }
+            }
+        }
+        System.out.println("sad");
+    }
+
+    private static int calculateDistance(Pos current, Pos next){
+        return Math.abs(current.x-next.x) + Math.abs(current.y-next.y);
+    }
+
+}
diff --git "a/CodeTree/2021-2022\353\205\204/YJ_\353\206\200\354\235\264\352\270\260\352\265\254_\355\203\221\354\212\271.java" "b/CodeTree/2021-2022\353\205\204/YJ_\353\206\200\354\235\264\352\270\260\352\265\254_\355\203\221\354\212\271.java"
new file mode 100644
index 00000000..d0548582
--- /dev/null
+++ "b/CodeTree/2021-2022\353\205\204/YJ_\353\206\200\354\235\264\352\270\260\352\265\254_\355\203\221\354\212\271.java"
@@ -0,0 +1,138 @@
+import java.util.*;
+import java.io.*;
+
+class Student {
+    int x;
+    int y;
+    int likeCount;
+    int blanckCount;
+
+    public Student(int x, int y, int likeCount, int blanckCount){
+        this.x=x;
+        this.y=y;
+        this.likeCount=likeCount;
+        this.blanckCount=blanckCount;
+    }
+
+    public boolean isBestPosition(Student best){
+        //1. 4방향 탐색 "좋아하는 친구"의 수가 가장 많은 위치로 이동
+        if(this.likeCount != best.likeCount){
+            return this.likeCount > best.likeCount;
+        }
+        //2. 4방향을 탐색해서 비어있는 위치 카운팅
+        else if(this.blanckCount != best.blanckCount){
+            return this.blanckCount > best.blanckCount;
+        }
+        //3. 그 중 행 번호가 가장 작은 위치로 이동
+        else if(this.x != best.x){
+            return this.x < best.x;
+        }
+        //4. 그 중 열 번호가 가장 작은 위치로 이동
+        return this.y < best.y;
+    }
+
+}
+
+public class YJ_놀이기구_탑승 {
+    static int[] numbers;  //학생들 번호
+    static Map<Integer,List<Integer>> likeStudents = new HashMap<>();    //학생별 좋아하는 번호
+    static int[][] ride;    //놀이기구 탑승
+    static int n=0;
+    static int TOTAL=0;
+    public static void main(String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        n = Integer.parseInt(br.readLine());
+        ride = new int[n][n];
+        TOTAL = n*n;
+        numbers = new int[TOTAL];
+
+        //입력값 초기화
+        for(int i=0; i<TOTAL; i++){
+            String[] line = br.readLine().split("\\s");
+            numbers[i] = Integer.parseInt(line[0]);
+
+            //좋아하는 학생 4명
+            List<Integer> likes = new ArrayList<>();
+            for(int j=0; j<4; j++){
+                likes.add(Integer.parseInt(line[j+1]));
+            }
+            likeStudents.put(numbers[i],likes);
+        }
+
+        for(int i=0; i<TOTAL; i++){
+            //학생 1명을 모든 구간을 탐색하며 최우선 자리에 앉히기
+            search(numbers[i], likeStudents.get(numbers[i]));
+        }
+
+        //점수판
+        int score = 0;
+        for(int i=0; i<n; i++){
+            for(int j=0; j<n; j++){
+                score += calculateScore(i,j);
+            }
+        }
+        System.out.println(score);
+    }
+
+    static void search(int number, List<Integer> likes){
+        Student best = new Student(n,n,-1,-1);
+        for(int i=0; i<n; i++){
+            for(int j=0; j<n; j++){
+                if(ride[i][j] != 0){
+                    continue;
+                }
+                Student student = getCountByCondition(likes,i,j);
+                if(student.isBestPosition(best)){
+                    best = student;
+                }
+            }
+        }
+        ride[best.x][best.y] = number;
+    }
+
+    static int[] nx = {0,1,0,-1};
+    static int[] ny = {1,0,-1,0};
+    private static Student getCountByCondition(List<Integer> likes, int currentX, int currentY){
+        int blanckCount=0;
+        int likeCount=0;
+
+        for(int i=0; i<4; i++){
+            int x = currentX + nx[i];
+            int y = currentY + ny[i];
+
+            if(stop(x,y)){
+                continue;
+            }
+            //2.비어있는 위치 카운팅
+            if(ride[x][y] == 0){
+                blanckCount++;
+            }
+            //1.좋아하는 친구 수 카운팅
+            else if(likes.contains(ride[x][y])){
+                likeCount++;
+            }
+        }
+        return new Student(currentX,currentY,likeCount,blanckCount);
+    }
+
+    static int[] scoreBoard = {0,1,10,100,1000};
+    static int calculateScore(int currentX, int currentY){
+        int friendCount = 0;
+        List<Integer> likes = likeStudents.get(ride[currentX][currentY]);
+        for(int p=0; p<4; p++){
+            int x = currentX + nx[p];
+            int y = currentY + ny[p];
+            if(stop(x,y)){
+                continue;
+            }
+            if(likes.contains(ride[x][y])){
+                friendCount++;
+            }
+        }
+        return scoreBoard[friendCount];
+    }
+
+    private static boolean stop(int x, int y){
+        return x < 0 || x >= n || y < 0 || y >= n;
+    }
+}
\ No newline at end of file
diff --git "a/CodeTree/2023-2024\353\205\204/YJ_\354\240\204\354\236\220\354\202\254\354\240\204_\353\247\214\353\223\244\352\270\260.java" "b/CodeTree/2023-2024\353\205\204/YJ_\354\240\204\354\236\220\354\202\254\354\240\204_\353\247\214\353\223\244\352\270\260.java"
new file mode 100644
index 00000000..e990cbad
--- /dev/null
+++ "b/CodeTree/2023-2024\353\205\204/YJ_\354\240\204\354\236\220\354\202\254\354\240\204_\353\247\214\353\223\244\352\270\260.java"
@@ -0,0 +1,111 @@
+import java.util.*;
+import java.io.*;
+
+/**
+ * 알고리즘: 이분탐색
+ * 시간복잡도: 1 ≤ N ≤ 100,000 → 10^5 으로 `O(NlogN)` 이내로 풀이하기
+ */
+public class YJ_전자사전_만들기 {
+    static Map<String,Integer> original = new HashMap<>();
+    static String[] dictionary = null;
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        String[] line1 = br.readLine().split("\\s");
+        int N = Integer.parseInt(line1[0]);
+        int T = Integer.parseInt(line1[1]);
+
+        dictionary = new String[N];
+        for(int i=0; i<N; i++){
+            String word = br.readLine();
+            dictionary[i] = word;
+            original.put(word,i+1);
+        }
+        Arrays.sort(dictionary);
+
+        int[] orders = new int[T];
+        String[] findWords = new String[T];
+        for(int i=0; i<T; i++){
+            String[] line2 = br.readLine().split("\\s");
+            orders[i] = Integer.parseInt(line2[0]);
+            findWords[i] = line2[1];
+        }
+
+        for(int i=0; i<T; i++){
+            int k = orders[i];
+            String value = findWords[i];
+
+            //검색된 단어들의 시작과 끝
+            int start = findStartSearch(value);
+            int end = findEndSearch(value);
+            //k 번째 단어 찾기
+            String word  = findWord(start,end,k);
+            //k번째 단어의 입력순서 찾기
+            int orderNo = word.isEmpty()?-1:original.get(word);
+            System.out.println(orderNo);
+        }
+
+        br.close();
+    }
+
+    static int findStartSearch(String target){
+        int left = 0;
+        int right = dictionary.length-1;
+        int start = dictionary.length-1;
+
+        while(left <= right){
+            int mid = (left+right)/2;
+            if(dictionary[mid].startsWith(target)){
+                start = mid;
+                right = mid-1;
+            }
+            //mid 값이 더 클 경우
+            else if (dictionary[mid].compareTo(target) > 0) {
+                right = mid-1;
+            }
+            //mid 값이 더 작을 경우
+            else{
+                left = mid+1;
+            }
+        }
+        return start;
+    }
+
+    static int findEndSearch(String target){
+        int left = 0;
+        int right = dictionary.length-1;
+        int end = 0;
+
+        while(left <= right){
+            int mid = (left+right)/2;
+            if(dictionary[mid].startsWith(target)){
+                end = mid;
+                left = mid+1;
+            }
+            //mid 값이 더 클 경우
+            else if (dictionary[mid].compareTo(target) > 0) {
+                right = mid-1;
+            }
+            //mid 값이 더 작을 경우
+            else{
+                left = mid+1;
+            }
+        }
+        return end;
+    }
+
+    static String findWord(int start, int end, int k){
+        if(end-start < k-1){
+            return "";
+        }
+        int j=0;
+        String target = "";
+        for(int i=start; i<=end; i++){
+            target = dictionary[i];
+            if(k-1 == j){
+                break;
+            }
+            j++;
+        }
+        return target;
+    }
+}
diff --git a/Programmers/Level3/YJ_214288.java b/Programmers/Level3/YJ_214288.java
new file mode 100644
index 00000000..7015f232
--- /dev/null
+++ b/Programmers/Level3/YJ_214288.java
@@ -0,0 +1,100 @@
+import java.util.*;
+
+/**
+ * 알고리즘: PriorityQueue + 구현
+ * 시간복잡도: 3 ≤ reqs의 길이 ≤ 300 으로 단순구현 가능
+ * 아이디어:
+ - 유형별 최소 대기시간 계산에 따라 최적의 멘토 인원 분배 수를 찾고, 최소시간 계산하기
+ - 유형별 멘토 인원 분배 방법
+ - PriorityQueue를 사용해서 여러 작업에서 가장 빨리 완료할 수 있는 작업부터 처리하기
+ - 여러 작업: 유형별 상담 요청
+ - 가장 빨리 완료: 상담종료 시간이 가장 적은 사람부터 처리
+ - 기다리는 시간을 계산하고, 상담 종료 시 다음 상담요청 배치
+ */
+public class YJ_214288 {
+    static class Participant {
+        int startTime;
+        int endTime;
+        int counseling;
+        int type;
+        public Participant(int startTime, int counseling, int type) {
+            this.startTime = startTime;
+            this.endTime = startTime+counseling;
+            this.counseling = counseling;
+            this.type = type;
+        }
+    }
+
+    static List<Participant> participantList = new ArrayList<>();
+    static int getTotalWaitingTime(int k, int n, int[][] reqs) {
+        for(int [] r : reqs){
+            participantList.add(new Participant(r[0],r[1],r[2]));
+        }
+
+        int[] typeMento = new int[k+1];
+        Arrays.fill(typeMento,1);   //유형별로 최소 1명의 상담원 배치
+        int remainingMento = n-k;
+
+        while(remainingMento > 0){
+            int minTime = Integer.MAX_VALUE;
+            int bestDivision = -1;
+            //임의로 상담원을 배치해서 최적의 상담원 배치 도출하기
+            for(int i=1; i<typeMento.length; i++){
+                typeMento[i]++;
+                int waitingTime = calcWaitingTime(typeMento);
+
+                //상담원 배정시 유형별로 가장 적은 대기 시간일 경우 유형 저장하기
+                minTime = Math.min(minTime, waitingTime);
+                if (minTime == waitingTime) {
+                    bestDivision = i;
+                }
+                typeMento[i]--;
+            }
+
+            typeMento[bestDivision]++;
+            remainingMento--;
+        }
+
+        return calcWaitingTime(typeMento);
+    }
+
+    //유형별 대기 시간의 총합 계산
+    private static int calcWaitingTime(int[] typeMento){
+        int totalWaitingTime = 0;
+
+        for(int type=1; type<typeMento.length; type++){
+            PriorityQueue<Integer> pq = new PriorityQueue<>();
+            int waitingTime = 0;
+            //유형별로 계산
+            for(Participant participant : participantList){
+                if(participant.type != type){
+                    continue;
+                }
+                if(pq.size() < typeMento[type]){
+                    pq.offer(participant.endTime);
+                    continue;
+                }
+
+                int minEndTime = pq.poll();
+                //대기시간 계산: 최소 상담종료시간 - 현재 사람의 상담 시작시간
+                waitingTime += Math.max(0,minEndTime-participant.startTime);
+                //현재 사람의 상담이 종료되는 가장 빠른 시간
+                int fastEndTime = Math.max(minEndTime,participant.startTime)+participant.counseling;
+                pq.offer(fastEndTime);
+            }
+
+            totalWaitingTime += waitingTime;
+        }
+
+        return totalWaitingTime;
+    }
+
+    public static void main(String[] args) {
+        int k = 3;
+        int n = 5;
+        int[][] reqs = {{10, 60, 1}, {15, 100, 3}, {20, 30, 1}, {30, 50, 3}, {50, 40, 1}, {60, 30, 2}, {65, 30, 1}, {70, 100, 2}};
+        System.out.println(getTotalWaitingTime(k, n, reqs));
+    }
+
+}
+
diff --git a/Programmers/Level3/YJ_42898.java b/Programmers/Level3/YJ_42898.java
new file mode 100644
index 00000000..06b26f40
--- /dev/null
+++ b/Programmers/Level3/YJ_42898.java
@@ -0,0 +1,29 @@
+public class YJ_42898 {
+     int solution(int m, int n, int[][] puddles) {
+        int[][] dp = new int[n+1][m+1];
+        final int CONDITION = 1000000007;
+        //물웅덩이 초기화 [1] x, [0] y
+        for(int i=0; i<puddles.length; i++){
+            dp[puddles[i][1]][puddles[i][0]] = -1;
+        }
+
+        dp[1][1] = 1;
+        for(int i=1; i<dp.length; i++){
+            for(int j=1; j<dp[0].length; j++){
+                //물웅덩이가 있을 경우 0으로 초기화
+                if(dp[i][j] == -1){
+                    continue;
+                }
+                //이때 특정지점을 구하는 방법은 이전 방향인 `왼쪽[j-1] +위[i-1] = 특정지점`
+                if(dp[i-1][j] > 0){ //위에서 오는 방향
+                    dp[i][j] = (dp[i-1][j]+dp[i][j]) % CONDITION;
+                }
+                if(dp[i][j-1] > 0){ //왼쪽에서 오는 방향
+                    dp[i][j] = (dp[i][j] + dp[i][j-1]) % CONDITION;
+                }
+            }
+        }
+
+        return dp[n][m];
+    }
+}
diff --git "a/SQL/05\354\243\274\354\260\250/YJ_\354\213\235\355\222\210\353\266\204\353\245\230\353\263\204 \352\260\200\354\236\245 \353\271\204\354\213\274 \354\213\235\355\222\210\354\235\230 \354\240\225\353\263\264 \354\241\260\355\232\214\355\225\230\352\270\260.sql" "b/SQL/05\354\243\274\354\260\250/YJ_\354\213\235\355\222\210\353\266\204\353\245\230\353\263\204 \352\260\200\354\236\245 \353\271\204\354\213\274 \354\213\235\355\222\210\354\235\230 \354\240\225\353\263\264 \354\241\260\355\232\214\355\225\230\352\270\260.sql"
new file mode 100644
index 00000000..cc56c5fd
--- /dev/null
+++ "b/SQL/05\354\243\274\354\260\250/YJ_\354\213\235\355\222\210\353\266\204\353\245\230\353\263\204 \352\260\200\354\236\245 \353\271\204\354\213\274 \354\213\235\355\222\210\354\235\230 \354\240\225\353\263\264 \354\241\260\355\232\214\355\225\230\352\270\260.sql"	
@@ -0,0 +1,12 @@
+--  식품분류가 '과자', '국', '김치', '식용유'인 경우만 출력
+--  식품 가격을 기준으로 내림차순 정렬
+SELECT
+    fp.CATEGORY, fp.PRICE, fp.PRODUCT_NAME
+FROM FOOD_PRODUCT fp
+         JOIN
+     (SELECT CATEGORY, MAX(PRICE) MAX_PRICE
+      FROM FOOD_PRODUCT
+      WHERE CATEGORY IN ('과자','국','김치','식용유')
+      GROUP BY CATEGORY) AS sub
+     ON fp.CATEGORY = sub.CATEGORY AND fp.PRICE = sub.MAX_PRICE
+ORDER BY fp.PRICE DESC;