diff --git a/youtube/BOJ2749.java b/youtube/BOJ2749.java
new file mode 100644
index 0000000..dddccf8
--- /dev/null
+++ b/youtube/BOJ2749.java
@@ -0,0 +1,67 @@
+import java.io.*;
+
+public class Main {
+    // 문제에서 요구한 나누는 수
+    final static long MOD = 1000000;
+
+    public static void main(String[] args) throws IOException {
+        // 입력 속도를 위해 BufferedReader 사용
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        
+        // n은 최대 100경(10^18)이므로 long 사용
+        long n = Long.parseLong(br.readLine());
+
+        // F_0 = 0
+        if (n == 0) {
+            System.out.println(0);
+            return;
+        }
+
+        // 피보나치 Q-행렬 기본값
+        long[][] A = {{1, 1}, {1, 0}};
+        
+        // 행렬 거듭제곱으로 Fn 구하기
+        long[][] result = power(A, n);
+
+        // M^n의 [0][1] 성분이 F_n임
+        System.out.println(result[0][1] % MOD);
+    }
+
+    // 분할 정복을 이용한 거듭제곱 (O(logN))
+    private static long[][] power(long[][] A, long n) {
+        // 지수가 1이면 자기 자신 반환 (Base Case)
+        if (n == 1) {
+            // 반환할 때도 모듈러 연산 안전하게 한 번 해줌
+            return new long[][] {
+                {A[0][0] % MOD, A[0][1] % MOD},
+                {A[1][0] % MOD, A[1][1] % MOD}
+            };
+        }
+
+        // 1. 반으로 쪼개서 구함 (Divide)
+        long[][] half = power(A, n / 2);
+
+        // 2. 구한 것을 제곱함 (Conquer)
+        long[][] result = multiply(half, half);
+
+        // 3. 홀수라면 A를 한 번 더 곱해줌
+        if (n % 2 == 1) {
+            result = multiply(result, A);
+        }
+
+        return result;
+    }
+
+    // 행렬 곱셈 함수 (나머지 연산 포함)
+    private static long[][] multiply(long[][] o1, long[][] o2) {
+        long[][] ret = new long[2][2];
+
+        // 2x2 행렬 곱셈 공식 + 모듈러 연산
+        ret[0][0] = (o1[0][0] * o2[0][0] + o1[0][1] * o2[1][0]) % MOD;
+        ret[0][1] = (o1[0][0] * o2[0][1] + o1[0][1] * o2[1][1]) % MOD;
+        ret[1][0] = (o1[1][0] * o2[0][0] + o1[1][1] * o2[1][0]) % MOD;
+        ret[1][1] = (o1[1][0] * o2[0][1] + o1[1][1] * o2[1][1]) % MOD;
+
+        return ret;
+    }
+}
diff --git "a/\352\267\270\353\236\230\355\224\204/P1325_\355\232\250\354\234\250\354\240\201\354\235\270\355\225\264\355\202\271.java" "b/\352\267\270\353\236\230\355\224\204/P1325_\355\232\250\354\234\250\354\240\201\354\235\270\355\225\264\355\202\271.java"
index 2e4334d..98ea35c 100644
--- "a/\352\267\270\353\236\230\355\224\204/P1325_\355\232\250\354\234\250\354\240\201\354\235\270\355\225\264\355\202\271.java"
+++ "b/\352\267\270\353\236\230\355\224\204/P1325_\355\232\250\354\234\250\354\240\201\354\235\270\355\225\264\355\202\271.java"
@@ -1,59 +1,59 @@
 import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.IOException;
 import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.Queue;
-import java.util.StringTokenizer;
+import java.util.*;
 public class P1325_효율적인해킹 {
-  static int N, M;
-  static boolean visited[];
-  static int answer[];
-  static ArrayList<Integer> A[];
-  public static void main(String[] args) throws IOException {
-    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
-    StringTokenizer st = new StringTokenizer(br.readLine());
-    N = Integer.parseInt(st.nextToken());
-    M = Integer.parseInt(st.nextToken());
-    A = new ArrayList[N + 1];
-    answer = new int[N + 1];
-    for (int i = 1; i <= N; i++)
-      A[i] = new ArrayList<>();
-    for (int i = 0; i < M; i++) {
-      st = new StringTokenizer(br.readLine());
-      int S = Integer.parseInt(st.nextToken());
-      int E = Integer.parseInt(st.nextToken());
-      A[S].add(E);
-    }
-    for (int i = 1; i <= N; i++) { //모든 정점에 대하여 BFS 실행
-      visited = new boolean[N + 1];
-      BFS(i);
-    }
-    int maxVal = 0;
-    for (int i = 1; i <= N; i++) {
-      maxVal = Math.max(maxVal, answer[i]);
-    }
-    for (int i = 1; i <= N; i++) {
-      if (answer[i] == maxVal) //answer배열에서 maxVal와 같은 값을 가진 index를 정답으로 출력
-        System.out.print(i + " ");
+    static boolean visited[]  = new boolean[10001];;
+    static int answer[] = new int[10001];;
+    static ArrayList<Integer> A[] = new ArrayList[10001];;
+
+    static Queue<Integer> queue = new ArrayDeque<Integer>();
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int N = Integer.parseInt(st.nextToken());
+        int M = Integer.parseInt(st.nextToken());
+
+        for (int i = 1; i <= N; i++)
+            A[i] = new ArrayList<>();
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int S = Integer.parseInt(st.nextToken());
+            int E = Integer.parseInt(st.nextToken());
+            A[S].add(E);
+        }
+        for (int i = 1; i <= N; i++) { //모든 정점에 대하여 BFS 실행
+            for (int j = 1; j <= N; j++) {
+                visited[j] = false;
+            }
+
+            BFS(i);
+        }
+
+        int maxVal = 0;
+        for (int i = 1; i <= N; i++) {
+            if (maxVal < answer[i]) {
+                maxVal = answer[i];
+            }
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 1; i <= N; i++) {
+            if (answer[i] == maxVal) //answer배열에서 maxVal와 같은 값을 가진 index를 정답으로 출력
+                sb.append(i).append(" ");
+        }
+        System.out.println(sb);
     }
-  }
-  public static void BFS(int index) {
-    Queue<Integer> queue = new LinkedList<Integer>();
-    queue.add(index);
-    visited[index] = true;
-    while (!queue.isEmpty()) {
-      int now_node = queue.poll();
-      for (int i : A[now_node]) {
-        if (visited[i] == false) {
-          visited[i] = true;
-          answer[i]++; //신규 정점인덱스의 정답 배열 값을 증가 시키기  
-          queue.add(i);
+    public static void BFS(int index) {
+        queue.add(index);
+        visited[index] = true;
+        while (!queue.isEmpty()) {
+            int now_node = queue.poll();
+            for (int i : A[now_node]) {
+                if (visited[i]) continue;
+                visited[i] = true;
+                answer[i]++; //신규 정점인덱스의 정답 배열 값을 증가 시키기
+                queue.add(i);
+            }
         }
-      }
     }
-  }
-}
\ No newline at end of file
+}
diff --git "a/\352\267\270\353\236\230\355\224\204/P1916_\354\265\234\354\206\214\353\271\204\354\232\251\352\265\254\355\225\230\352\270\260.java" "b/\352\267\270\353\236\230\355\224\204/P1916_\354\265\234\354\206\214\353\271\204\354\232\251\352\265\254\355\225\230\352\270\260.java"
index 913e9d0..6c24348 100644
--- "a/\352\267\270\353\236\230\355\224\204/P1916_\354\265\234\354\206\214\353\271\204\354\232\251\352\265\254\355\225\230\352\270\260.java"
+++ "b/\352\267\270\353\236\230\355\224\204/P1916_\354\265\234\354\206\214\353\271\204\354\232\251\352\265\254\355\225\230\352\270\260.java"
@@ -6,70 +6,88 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 import java.util.StringTokenizer;
-public class P1916_최소비용구하기 {
-  static int N, M;
-  static ArrayList<Node_1916>[] list; // 인접리스트로 그래프 표현하기.
-  static int[] dist; // 최단거리 배열.
-  static boolean[] visit; // 사용노드인지 확인하는 배열.
-  public static void main(String[] args) throws Exception {
-    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
-    StringTokenizer st;
-    N = Integer.parseInt(br.readLine());
-    M = Integer.parseInt(br.readLine());
-    list = new ArrayList[N + 1];
-    dist = new int[N + 1];
-    visit = new boolean[N + 1];
-    Arrays.fill(dist, Integer.MAX_VALUE);
-    for (int i = 0; i <= N; i++) {
-      list[i] = new ArrayList<Node_1916>();
+ 
+class node implements Comparable<node> {
+    int targetNode;
+    int value;
+ 
+    node(int targetNode, int value) {
+        this.targetNode = targetNode;
+        this.value = value;
     }
-    for (int i = 0; i < M; i++) { // 주어진 그래프의 간선들을 인접리스트 자료구조에 넣는 부분
-      st = new StringTokenizer(br.readLine());
-      int start = Integer.parseInt(st.nextToken());
-      int end = Integer.parseInt(st.nextToken());
-      int weight = Integer.parseInt(st.nextToken());
-      list[start].add(new Node_1916(end, weight));
+ 
+    @Override
+    public int compareTo(node o) {
+        return value - o.value;
     }
-    st = new StringTokenizer(br.readLine());
-    int startIndex = Integer.parseInt(st.nextToken());
-    int endIndex = Integer.parseInt(st.nextToken());
-    // 다익스트라 알고리즘 수행
-    bw.write(dijkstra(startIndex, endIndex) + "\n");
-    bw.flush();
-    bw.close();
-    br.close();
-  }
-  public static int dijkstra(int start, int end) {   // 다익스트라 알고리즘
-    PriorityQueue<Node_1916> pq = new PriorityQueue<>();
-    pq.offer(new Node_1916(start, 0));
-    dist[start] = 0;
-    while (!pq.isEmpty()) {
-      Node_1916 nowNode_1916 = pq.poll();
-      int now = nowNode_1916.targetNode_1916;
-      if (!visit[now]) {
-        visit[now] = true;
-        for (Node_1916 n : list[now]) { // 선택노드 + 비용 < 타켓노드인 경우 값을 갱신하는 부분
-          if (!visit[n.targetNode_1916] && dist[n.targetNode_1916] > dist[now] + n.value) {
-            dist[n.targetNode_1916] = dist[now] + n.value;
-            pq.add(new Node_1916(n.targetNode_1916, dist[n.targetNode_1916]));
-          }
+ 
+}
+ 
+public class P1916_최소비용구하기 {
+    static int N, M;
+    static ArrayList<node>[] list; // 인접리스트로 그래프 표현하기.
+    static int[] dist; // 최단거리 배열.
+    static boolean[] check; // 사용노드인지 확인하는 배열.
+ 
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        StringTokenizer st;
+        N = Integer.parseInt(br.readLine());
+        M = Integer.parseInt(br.readLine());
+ 
+        list = new ArrayList[N+1];
+        dist = new int[N + 1];
+        check = new boolean[N + 1];
+ 
+        Arrays.fill(dist, Integer.MAX_VALUE);
+ 
+        for (int i = 0; i <= N; i++) {
+        	list[i] = new ArrayList<node>();
+        }
+ 
+        // 주어진 그래프의 간선들을 인접리스트 자료구조에 넣는 부분
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int start = Integer.parseInt(st.nextToken());
+            int end = Integer.parseInt(st.nextToken());
+            int weight = Integer.parseInt(st.nextToken());
+ 
+            list[start].add(new node(end, weight));
         }
-      }
+ 
+        st = new StringTokenizer(br.readLine());
+        int startIndex = Integer.parseInt(st.nextToken());
+        int endIndex = Integer.parseInt(st.nextToken());
+ 
+        //다익스트라 알고리즘 수행 
+        bw.write(dijkstra(startIndex, endIndex) + "\n");
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+ 
+    // 다익스트라 알고리즘
+    public static int dijkstra(int start, int end) {
+        PriorityQueue<node> pq = new PriorityQueue<>();
+        boolean[] check = new boolean[N + 1];
+        pq.offer(new node(start, 0));
+        dist[start] = 0;
+ 
+        while (!pq.isEmpty()) {
+        	node nowNode = pq.poll();
+            int now = nowNode.targetNode;
+ 
+            if (!check[now]) {
+                check[now] = true;
+                for (node n : list[now]) {  //선택노드 + 가중치 < 타켓노드인 경우 값을 갱신하는 부분
+                    if (dist[n.targetNode] > dist[now] + n.value) {
+                        dist[n.targetNode] = dist[now] + n.value;
+                        pq.add(new node(n.targetNode, dist[n.targetNode]));
+                    }
+                }
+            }
+        }
+        return dist[end];
     }
-    return dist[end];
-  }
-}
-class Node_1916 implements Comparable<Node_1916> {
-  int targetNode_1916;
-  int value;
-
-  Node_1916(int targetNode_1916, int value) {
-    this.targetNode_1916 = targetNode_1916;
-    this.value = value;
-  }
-  @Override
-  public int compareTo(Node_1916 o) {
-    return value - o.value;
-  }
 }
diff --git "a/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\353\220\234\354\240\225\354\210\230\354\235\230\355\225\251.java" "b/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\355\225\2512.java"
similarity index 94%
rename from "\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\353\220\234\354\240\225\354\210\230\354\235\230\355\225\251.java"
rename to "\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\355\225\2512.java"
index 4788c7e..26d0fd9 100644
--- "a/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\353\220\234\354\240\225\354\210\230\354\235\230\355\225\251.java"
+++ "b/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P13398_\354\227\260\354\206\215\355\225\2512.java"
@@ -1,7 +1,7 @@
 import java.io.*;
 import java.util.StringTokenizer;
 
-public class P13398_연속된정수의합 {
+public class P13398_연속합2 {
   public static void main(String[] args) throws IOException {
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
@@ -36,3 +36,4 @@ public static void main(String[] args) throws IOException {
     br.close();
   }
 }
+
diff --git "a/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P2098_\354\231\270\355\214\220\354\233\220\354\210\234\355\232\214.java" "b/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P2098_\354\231\270\355\214\220\354\233\220\354\210\234\355\232\214.java"
index 1447d7e..297f2fa 100644
--- "a/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P2098_\354\231\270\355\214\220\354\233\220\354\210\234\355\232\214.java"
+++ "b/\353\217\231\354\240\201\352\263\204\355\232\215\353\262\225/P2098_\354\231\270\355\214\220\354\233\220\354\210\234\355\232\214.java"
@@ -2,41 +2,38 @@
 import java.io.InputStreamReader;
 import java.util.StringTokenizer;
 class P2098_외판원순회 {
-    private static final int INF = 1000000*16+1;
     private static int N;
     private static int[][] W;
     private static int[][] d;
+    private static final int INF = 1000000*16+1;
     public static void main(String[] args) throws Exception {
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = null;
         N = Integer.parseInt(br.readLine().trim());
         W = new int[16][16];
+        d = new int[16][1 << 16];
         for (int i = 0; i < N; i++) {
             st = new StringTokenizer(br.readLine().trim());
             for (int j = 0; j < N; j++) {
                 W[i][j] = Integer.parseInt(st.nextToken());
             }
         }
-        d = new int[16][1 << 16];
-        for (int i = 0; i < N; i++) {
-            for (int j = 0; j < 1 << N; j++) {
-                d[i][j] = INF; //모든 비용을 충분히 큰수로 저장
-            }
-        }
         System.out.println(tsp(0, 1));
     }
     private static int tsp(int c, int v) { //모든 경우의 수에 대한 완전 탐색, 재귀 구현
         if (v == (1 << N) - 1) {    // 모든 노드를 방문한 경우
             return W[c][0] == 0 ? INF : W[c][0];
         }
-        if (d[c][v] != INF) {  //이미 방문한 노드인 경우 -> 이미 계산한 경우 바로 리턴 (메모이제이션)
+        if (d[c][v] != 0) {  //이미 방문한 노드인 경우 -> 이미 계산한 경우 바로 리턴 (메모이제이션)
             return d[c][v];
         }
+        int min_val = INF;
         for (int i = 0; i < N; i++) {
             if ((v & (1 << i)) == 0 && W[c][i] != 0) {   //방문한적이 없고 갈 수 있는 도시인 경우
-                d[c][v] = Math.min(d[c][v], tsp(i, (v | (1 << i))) + W[c][i]);
+                min_val = Math.min(min_val, tsp(i, (v | (1 << i))) + W[c][i]);
             }
         }
+        d[c][v] = min_val;
         return d[c][v];
     }
-}
\ No newline at end of file
+}
diff --git "a/\354\240\225\353\240\254/P11004_K\353\262\210\354\247\270\354\210\230.java" "b/\354\240\225\353\240\254/P11004_K\353\262\210\354\247\270\354\210\230.java"
index d67f9fc..a0aebe0 100644
--- "a/\354\240\225\353\240\254/P11004_K\353\262\210\354\247\270\354\210\230.java"
+++ "b/\354\240\225\353\240\254/P11004_K\353\262\210\354\247\270\354\210\230.java"
@@ -43,14 +43,16 @@ private static int partition(int[] A, int S, int E){
     int i = S+1, j = E;
     
     while (i <= j) {
-        while (pivot < A[j] && j > 0 ){   //피벗보다 작은 수가 나올때까지 j--
+        while (j>= S+1 && pivot < A[j]){   //피벗보다 작은 수가 나올때까지 j--
             j--;    
         }
-        while (pivot > A[i]  && i <A.length-1){  //피벗보다 큰 수가 나올 떄까지 i++
+        while (i<= E && pivot > A[i]){  //피벗보다 큰 수가 나올 떄까지 i++
                i ++;  
         }
-        if (i <= j) {
+        if (i < j) {
             swap (A, i++, j--);  // 찾은 i와 j를 교환하기
+        }else{
+            break;
         }
     }
     // i == j 피벗의 값을 양쪽으로 분리한 가운데에 오도록 설정하기
diff --git "a/\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\206\214\355\212\2701.java" "b/\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\240\225\353\240\2541.java"
similarity index 93%
rename from "\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\206\214\355\212\2701.java"
rename to "\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\240\225\353\240\2541.java"
index aea547c..725f9d5 100644
--- "a/\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\206\214\355\212\2701.java"
+++ "b/\354\240\225\353\240\254/P1377_\353\262\204\353\270\224\354\240\225\353\240\2541.java"
@@ -2,7 +2,7 @@
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.Arrays;
-public class P1377_버블소트1 {
+public class P1377_버블정렬1 {
   public static void main(String[] args) throws IOException {
     BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
     int N = Integer.parseInt(reader.readLine());
@@ -36,3 +36,4 @@ public int compareTo(mData o) {//value 기준 오름차순 정렬
   }
 }
 
+
diff --git "a/\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\206\214\355\212\2702.java" "b/\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\240\225\353\240\2542.java"
similarity index 94%
rename from "\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\206\214\355\212\2702.java"
rename to "\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\240\225\353\240\2542.java"
index b3cce26..bef6541 100644
--- "a/\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\206\214\355\212\2702.java"
+++ "b/\354\240\225\353\240\254/P1517_\353\262\204\353\270\224\354\240\225\353\240\2542.java"
@@ -3,7 +3,7 @@
 import java.io.InputStreamReader;
 import java.util.Arrays;
 import java.util.StringTokenizer;
-public class P1517_버블소트2 {
+public class P1517_버블정렬2 {
   public static int[] A, tmp;
   public static long result;
   public static void main(String[] args) throws IOException {
@@ -58,3 +58,4 @@ private static void merget_sort(int s, int e) {
 
   }
 }
+
diff --git "a/\355\203\220\354\203\211/P1206_DFS\354\231\200BFS.java" "b/\355\203\220\354\203\211/P1260_DFS\354\231\200BFS.java"
similarity index 94%
rename from "\355\203\220\354\203\211/P1206_DFS\354\231\200BFS.java"
rename to "\355\203\220\354\203\211/P1260_DFS\354\231\200BFS.java"
index 9e991c2..932aee5 100644
--- "a/\355\203\220\354\203\211/P1206_DFS\354\231\200BFS.java"
+++ "b/\355\203\220\354\203\211/P1260_DFS\354\231\200BFS.java"
@@ -1,5 +1,5 @@
 import java.util.*;
-public class P1206_DFS와BFS {
+public class P1260_DFS와BFS {
   static boolean visited[];
   static ArrayList<Integer>[] A;
   public static void main(String[] args) {
@@ -57,3 +57,4 @@ private static void BFS(int node) {  // BFS구현
     }
   }
 }
+
diff --git "a/\355\203\220\354\203\211/P15649_N\352\263\274M.java" "b/\355\203\220\354\203\211/P15649_N\352\263\274M.java"
new file mode 100644
index 0000000..500601f
--- /dev/null
+++ "b/\355\203\220\354\203\211/P15649_N\352\263\274M.java"
@@ -0,0 +1,39 @@
+import java.util.Scanner;
+
+public class P15649_N과M {
+    static int N, M;
+    static boolean[] V; // 숫자 사용 여부 저장
+    static int[] S;     // 수열 정보 저장
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        N = sc.nextInt();
+        M = sc.nextInt();
+        S = new int[N];
+        V = new boolean[N];
+        backtracking(0);
+    }
+
+    private static void backtracking(int length) {
+        if (length == M) {  // 길이가 M인 수열이 만들어진 경우
+            printArray();
+            return;
+        }
+        for (int i = 0; i < N; i++) {
+            if (!V[i]) {
+                V[i] = true;    //수 사용여부 저장
+                S[length] = i;  //수열에 수 사용하기
+                backtracking(length + 1);
+                V[i] = false;   //수 반납여부 저장
+            }
+        }
+    }
+
+    private static void printArray() {  // 수열 내용 출력
+        for (int i = 0; i < M; i++) {
+            System.out.print(S[i] + 1 + " ");
+        }
+        System.out.println();
+    }
+
+}
diff --git "a/\355\203\220\354\203\211/P17136_\354\203\211\354\242\205\354\235\264\353\266\231\354\235\264\352\270\260.java" "b/\355\203\220\354\203\211/P17136_\354\203\211\354\242\205\354\235\264\353\266\231\354\235\264\352\270\260.java"
new file mode 100644
index 0000000..aa50009
--- /dev/null
+++ "b/\355\203\220\354\203\211/P17136_\354\203\211\354\242\205\354\235\264\353\266\231\354\235\264\352\270\260.java"
@@ -0,0 +1,71 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class P17136_색종이붙이기 {
+
+    static int[][] M = new int[10][10];
+    static int[] S = {0, 5, 5, 5, 5, 5};    // 남은 색종이 수
+    static int result = Integer.MAX_VALUE;  // 최소 사용 갯수
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        for (int i = 0; i < 10; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < 10; j++) {
+                M[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+        // 1이 적힌 모든 칸을 붙이는 색종이를 사용한 경우의 수를 백트래킹으로 탐색
+        Backtracking(0, 0); 
+        if (result == Integer.MAX_VALUE) {
+            System.out.println(-1);
+        } else {
+            System.out.println(result);
+        }
+    }
+
+    static void Backtracking(int xy, int useCnt) {
+        if (xy == 100) {    //색종이로 1이 적힌 모든 칸을 붙였을 때 (x, y 좌표를 끝까지 탐색 한 경우 ) 탐색 종료
+            result = Math.min(useCnt, result);
+            return;
+        }
+        int x = xy % 10;
+        int y = xy / 10;
+
+        //가지치기 : 최소로 사용한 색종이 수보다 현재 탐색에서 사용한 색종이 수가 많으면 더이상 탐색 불필요
+        if (result <= useCnt) return;
+        if (M[y][x] == 1) {
+            for (int i = 5; i > 0; i--) {
+                if (S[i] > 0 && check(x, y, i)) {
+                    S[i]--; // 종이 사용하기
+                    fill(x, y, i, 0); // 종이 붙이기: 종이로 덮이는 부분 1-> 0으로 변경
+                    Backtracking(xy + 1, useCnt + 1);
+                    S[i]++; // 사용한 종이 다시 채우기
+                    fill(x, y, i, 1); // 종이 떼어내기 : 기존에 덮인 부분 0 -> 1 값으로 변경
+                }
+            }
+        } else {
+            Backtracking(xy + 1, useCnt); // 현재 좌표의 값이 0이면 색종이를 사용하지 않고 다음 칸 이동
+        }
+    }
+
+    static void fill(int x, int y, int size, int num) {
+        for (int i = y; i < y + size; i++) {
+            for (int j = x; j < x + size; j++) {
+                M[i][j] = num;
+            }
+        }
+    }
+
+    static boolean check(int x, int y, int size) {
+        if (x + size > 10 || y + size > 10) return false;
+        for (int i = y; i < y + size; i++) {
+            for (int j = x; j < x + size; j++) {
+                if (M[i][j] != 1) return false;
+            }
+        }
+        return true;
+    }
+}
diff --git "a/\355\203\220\354\203\211/P1920_\354\233\220\355\225\230\353\212\224\354\240\225\354\210\230\354\260\276\352\270\260.java" "b/\355\203\220\354\203\211/P1920_\354\233\220\355\225\230\353\212\224\354\240\225\354\210\230\354\260\276\352\270\260.java"
index f1196d2..e39cd9f 100644
--- "a/\355\203\220\354\203\211/P1920_\354\233\220\355\225\230\353\212\224\354\240\225\354\210\230\354\260\276\352\270\260.java"
+++ "b/\355\203\220\354\203\211/P1920_\354\233\220\355\225\230\353\212\224\354\240\225\354\210\230\354\260\276\352\270\260.java"
@@ -1,40 +1,44 @@
-import java.util.Arrays;
-import java.util.Scanner;
+import java.util.*;
+import java.io.*;
 public class P1920_원하는정수찾기 {
-  public static void main(String[] args) {
-    Scanner sc = new Scanner(System.in);
-    int N = sc.nextInt();
-    int[] A = new int[N];
-    for (int i = 0; i < N; i++) {
-      A[i] = sc.nextInt();
-    }
-    Arrays.sort(A);
-    int M = sc.nextInt();
-    for (int i = 0; i < M; i++) {
-      boolean find = false;
-      int target = sc.nextInt();
-      // 이진 탐색 시작
-      int start = 0;
-      int end = A.length - 1;
-      while (start <= end) {
-        int midi = (start + end) / 2;
-        int midV = A[midi];
-        if (midV > target) {
-          end = midi - 1;
-        } else if (midV < target) {
-          start = midi + 1;
-        } else {
-          find = true;
-          break;
+  public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+        int[] A = new int[N];
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < N; i++) {
+            A[i] = Integer.parseInt(st.nextToken());
+        }
+        Arrays.sort(A);
+        int M = Integer.parseInt(br.readLine());
+        st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < M; i++) {
+            boolean find = false;
+            int target = Integer.parseInt(st.nextToken());
+            //이진 탐색 시작
+            int start = 0;
+            int end = A.length - 1; 
+            while (start <= end) {
+                int midi = (start + end) / 2;
+                int midV = A[midi];
+                if (midV > target) {
+                    end = midi - 1;
+                } else if (midV < target) {
+                  start = midi + 1;
+                } else {
+                    find = true;
+                    break;
+                }
+            }
+            if (find) {
+              System.out.println(1);
+            }
+            else
+            {
+              System.out.println(0);
+            }
         }
-      }
-      if (find) {
-        System.out.println(1);
-      } else {
-        System.out.println(0);
-      }
     }
-  }
 }
 
 
diff --git "a/\355\203\220\354\203\211/P9663_NQueen.java" "b/\355\203\220\354\203\211/P9663_NQueen.java"
new file mode 100644
index 0000000..2ac805b
--- /dev/null
+++ "b/\355\203\220\354\203\211/P9663_NQueen.java"
@@ -0,0 +1,36 @@
+import java.util.Scanner;
+
+public class P9663_NQueen {
+    static int[] A;         //퀸 배치 정보 저장
+    static int N;           //체스판 크기 N*N
+    static int cnt = 0;     //퀸을 배치하는 경우의 수 저장
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        N = sc.nextInt();
+        A = new int[N];
+        backtracking(0);
+        System.out.println(cnt);
+    }
+
+    private static void backtracking(int row) {
+        if (row == N) { // 퀸 N개 모두 배치한 경우
+            cnt++;
+            return;
+        }
+        for (int i = 0; i < N; i++) {
+            A[row] = i;
+            if (check(row)) {   //이번에 배치한 퀸이 전에 배치했던 퀸들과 서로 공격할 수 없는지 체크
+                backtracking(row + 1);
+            }
+        }
+    }
+
+    private static boolean check(int row) {
+        for (int i = 0; i < row; i++) {
+            if (A[i] == A[row]) return false;   // 일직선 배치되어 있는 경우
+            if (Math.abs(row - i) == Math.abs(A[i] - A[row])) return false;  // 대각선으로 배치되어 있는 경우  
+        }
+        return true;
+    }
+}