diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index e69911a..ace0fe8 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,15 +1,75 @@
-- closed #000
-
-### Week 00 (00.00.00.)
-| Category | Title | Link |
-| :------: | :---: | :--: |
-|  | <a href="https://www.acmicpc.net/problem/문제번호"></a> | <a href="">🔗</a> |
-|  | <a href="https://www.acmicpc.net/problem/문제번호"></a> | <a href="">🔗</a> |
-|  | <a href="https://www.acmicpc.net/problem/문제번호"></a> | <a href="">🔗</a> |
-|  | <a href="https://www.acmicpc.net/problem/문제번호"></a> | <a href="">🔗</a> |
-|  | <a href="https://www.acmicpc.net/problem/문제번호"></a> | <a href="">🔗</a> |
-<br>
-
-```
-To. Reviewers
-```
+# 🚀 싸피 15반 알고리즘 스터디 5주차 [이준희] 
+
+## 📌 문제 풀이 개요
+- 이번 PR에서는 다음 5문제의 풀이를 포함합니다.
+- 각 문제에 대한 풀이 과정과 접근 방식을 설명합니다.
+---
+
+## ✅ 문제 해결 여부
+
+  - [x] **문제 1**
+  - [x] **문제 2**  
+  - [ ] **문제 3**
+  - [x] **문제 4**  
+  - [ ] **문제 5**  
+
+---
+
+## 💡 풀이 방법
+### 문제 1: 문제 이름 
+(문제 이름은 현재 문제에 맞게 바꿔주세요! 바꾸시고 이 문장을 지워주세요.)
+
+**문제 난이도**
+
+
+
+**문제 유형**
+
+
+
+ **접근 방식 및 풀이**
+
+   
+---
+
+
+
+### 문제 2: 문제 이름 
+ **문제 유형**
+
+
+
+ **접근 방식 및 풀이**
+
+
+
+---
+### 문제 3: 문제 이름 
+ **문제 유형**
+
+
+
+
+
+
+ **접근 방식 및 풀이**
+
+
+---
+### 문제 4: 문제 이름 
+ **문제 유형**
+
+
+
+ **접근 방식 및 풀이**
+
+
+---
+### 문제 5: 문제 이름 
+ **문제 유형**
+
+
+
+ **접근 방식 및 풀이**
+
+
diff --git a/pullrequesttest.java b/pullrequesttest.java
new file mode 100644
index 0000000..e69de29
diff --git a/week10/BOJ11403.java b/week10/BOJ11403.java
new file mode 100644
index 0000000..0248661
--- /dev/null
+++ b/week10/BOJ11403.java
@@ -0,0 +1,51 @@
+package week10;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ11403 {
+
+	static int[][] arr;
+	static int n;
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+		n = Integer.parseInt(br.readLine());
+		arr = new int[n + 1][n + 1];
+		for (int i = 1; i <= n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 1; j <= n; j++) {
+				int a = Integer.parseInt(st.nextToken());
+				if (a == 1)
+					arr[i][j] = 1;
+				else
+					arr[i][j] = 101;
+			}
+		}
+
+		for (int k = 1; k <= n; k++) { // 플로이드-워셜 알고리즘으로 모든 점에서 다른 모든 점으로의 거리 계산
+			for (int i = 1; i <= n; i++) {
+				for (int j = 1; j <= n; j++) {
+					arr[i][j] = Math.min(arr[i][j], arr[i][k] + arr[k][j]);
+				}
+			}
+		}
+
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				if (arr[i][j] > 100 || arr[i][j] == 0) {
+					System.out.print("0 ");
+				} else {
+					System.out.print("1 ");
+				}
+			}
+			System.out.println();
+		}
+
+	}
+
+}
+
diff --git a/week10/BOJ1197.java b/week10/BOJ1197.java
new file mode 100644
index 0000000..2f7f427
--- /dev/null
+++ b/week10/BOJ1197.java
@@ -0,0 +1,87 @@
+package week10;
+
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ1197 {
+
+	static class Edge implements Comparable<Edge> {
+		int from, to, weight;
+
+		public Edge(int from, int to, int weight) {
+			super();
+			this.from = from;
+			this.to = to;
+			this.weight = weight;
+		}
+
+		@Override
+		public int compareTo(Edge o) {
+			return Integer.compare(this.weight, o.weight);
+		}
+
+	}
+
+	static int V, E;
+	static int[] parents;
+	static Edge[] edgeList;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st= new StringTokenizer(br.readLine());
+
+		V = Integer.parseInt(st.nextToken());
+		E = Integer.parseInt(st.nextToken());
+		parents = new int[V + 1];
+		edgeList = new Edge[2*E];
+		for (int i = 1; i <= V; i++) {
+			parents[i] = i;
+		}
+
+		for (int i = 0; i < E; i++) {
+			st = new StringTokenizer(br.readLine());
+			int from = Integer.parseInt(st.nextToken());
+			int to = Integer.parseInt(st.nextToken());
+			int w = Integer.parseInt(st.nextToken());
+
+			edgeList[i] = new Edge(from, to, w); // 무향 그래프이므로 from to 번갈아 저장
+            edgeList[E+i] = new Edge(to, from, w);
+		}
+		
+		Arrays.sort(edgeList);
+		long result = 0, count = 0;
+
+		for (Edge edge : edgeList) { // edge 마다 탐색
+			if (union(edge.from, edge.to)) {
+				result += edge.weight;
+				if (++count == V - 1) {
+					break;
+				}
+			}
+		}
+		
+		System.out.println(result);
+	}
+	
+	static int find(int a) {
+		if (a == parents[a])
+			return a;
+		return parents[a] = find(parents[a]);
+	}
+	
+	static boolean union(int a, int b) {
+		int aRoot = find(a);
+		int bRoot = find(b);
+
+		if (aRoot == bRoot)
+			return false;
+
+		parents[bRoot] = aRoot;
+		return true;
+	}
+
+}
+
diff --git a/week10/BOJ1238.java b/week10/BOJ1238.java
new file mode 100644
index 0000000..f94ea81
--- /dev/null
+++ b/week10/BOJ1238.java
@@ -0,0 +1,124 @@
+package week10;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+class Node implements Comparable<Node> {
+	int index;
+	int weight;
+
+	public Node(int index, int cost) {
+		this.index = index;
+		this.weight = cost;
+	}
+
+	@Override
+	public int compareTo(Node o) {
+		return Integer.compare(this.weight, o.weight);
+	}
+}
+
+public class BOJ1238 {
+
+	static int n, m, x;
+	static ArrayList<Node>[] graph;
+	static ArrayList<Node>[] graph2;
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+		x = Integer.parseInt(st.nextToken());
+
+		graph = new ArrayList[n + 1]; // 목적지 도착용
+		graph2 = new ArrayList[n + 1]; // 목적지에서 귀가용
+
+		for (int i = 0; i <= n; i++) {
+			graph[i] = new ArrayList<>();
+			graph2[i] = new ArrayList<>();
+		}
+
+		for (int i = 0; i < m; i++) {
+			st = new StringTokenizer(br.readLine());
+			int u = Integer.parseInt(st.nextToken());
+			int v = Integer.parseInt(st.nextToken());
+			int w = Integer.parseInt(st.nextToken());
+
+			graph[v].add(new Node(u, w));
+			graph2[u].add(new Node(v, w));
+		}
+
+		int[] dist = Dijkstra(x);
+		int[] dist2 = Dijkstra2(x);
+		int max = 0;
+		for (int i = 1; i <= n; i++) {
+			max = Math.max(max, dist[i] + dist2[i]);
+		}
+		System.out.println(max);
+	}
+
+	public static int[] Dijkstra(int start) { // 목적지 도착용
+		boolean[] check = new boolean[n + 1];
+		int[] dist = new int[n + 1];
+		int INF = Integer.MAX_VALUE;
+
+		Arrays.fill(dist, INF);
+		dist[start] = 0;
+
+		PriorityQueue<Node> pq = new PriorityQueue<>();
+		pq.offer(new Node(start, 0));
+
+		while (!pq.isEmpty()) {
+			int nowVertex = pq.poll().index;
+
+			if (check[nowVertex])
+				continue;
+			check[nowVertex] = true;
+
+			for (Node next : graph[nowVertex]) {
+				if (dist[next.index] > dist[nowVertex] + next.weight) {
+					dist[next.index] = dist[nowVertex] + next.weight;
+
+					pq.offer(new Node(next.index, dist[next.index]));
+				}
+			}
+		}
+
+		return dist;
+	}
+
+	public static int[] Dijkstra2(int start) { // 목적지 출발용
+		boolean[] check = new boolean[n + 1];
+		int[] dist = new int[n + 1];
+		int INF = Integer.MAX_VALUE;
+
+		Arrays.fill(dist, INF);
+		dist[start] = 0;
+
+		PriorityQueue<Node> pq = new PriorityQueue<>();
+		pq.offer(new Node(start, 0));
+
+		while (!pq.isEmpty()) {
+			int nowVertex = pq.poll().index;
+
+			if (check[nowVertex])
+				continue;
+			check[nowVertex] = true;
+
+			for (Node next : graph2[nowVertex]) {
+				if (dist[next.index] > dist[nowVertex] + next.weight) {
+					dist[next.index] = dist[nowVertex] + next.weight;
+
+					pq.offer(new Node(next.index, dist[next.index]));
+				}
+			}
+		}
+		return dist;
+	}
+}
diff --git a/week10/BOJ14940.java b/week10/BOJ14940.java
new file mode 100644
index 0000000..1521f28
--- /dev/null
+++ b/week10/BOJ14940.java
@@ -0,0 +1,78 @@
+package week10;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ14940 {
+
+    static int n, m, x, y;
+    static int[][] map;
+    static int[][] dist;
+    static boolean[][] visited;
+    static int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        map = new int[n][m];
+        dist = new int[n][m];
+        visited = new boolean[n][m];
+
+        // 맵 입력 받기
+        for (int i = 0; i < n; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < m; j++) {
+                int num = Integer.parseInt(st.nextToken());
+                if (num == 2) { // 목표 지점
+                    y = i;
+                    x = j;
+                    map[i][j] = 0; // 목표 지점은 0으로 초기화
+                } else {
+                    map[i][j] = num;
+                }
+                dist[i][j] = -1; // 초기화: 거리 정보는 -1로 설정
+                if(map[i][j]==0)
+                	dist[i][j]=0;
+            }
+        }
+
+        // BFS 시작
+        bfs(y, x);
+
+        // 결과 출력
+        for (int[] row : dist) {
+            for (int cell : row) {
+                System.out.print(cell + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    public static void bfs(int startY, int startX) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{startY, startX});
+        dist[startY][startX] = 0; // 목표 지점의 거리는 0
+
+        while (!queue.isEmpty()) {
+            int[] current = queue.poll();
+            int y = current[0];
+            int x = current[1];
+
+            for (int i = 0; i < 4; i++) {
+                int dy = y + dir[i][0];
+                int dx = x + dir[i][1];
+
+                if (dy >= 0 && dy < n && dx >= 0 && dx < m && map[dy][dx] == 1 && dist[dy][dx] == -1) {
+                    dist[dy][dx] = dist[y][x] + 1;
+                    queue.offer(new int[]{dy, dx});
+                }
+            }
+        }
+    }
+}
diff --git a/week10/BOJ16928.java b/week10/BOJ16928.java
new file mode 100644
index 0000000..fe06f7c
--- /dev/null
+++ b/week10/BOJ16928.java
@@ -0,0 +1,77 @@
+package week10;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ16928 {
+
+    static int[] arr = new int[101]; // 사다리와 뱀의 정보를 저장하는 배열
+    static boolean[] visited = new boolean[101]; // 방문 여부를 체크하는 배열
+    static int n, m;
+
+    public static void main(String[] args) throws Exception {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+
+        // 사다리와 뱀의 정보 입력
+        for (int i = 0; i < n + m; i++) {
+            st = new StringTokenizer(br.readLine());
+            int from = Integer.parseInt(st.nextToken());
+            int to = Integer.parseInt(st.nextToken());
+            arr[from] = to; // 사다리 또는 뱀의 이동 정보를 저장
+        }
+
+        // BFS 수행
+        System.out.println(bfs(1)); // 시작 지점은 1
+    }
+
+    static int bfs(int start) {
+        Queue<Integer> queue = new ArrayDeque<>();
+        queue.add(start);
+        visited[start] = true; // 시작 위치 방문 처리
+        int count = 0; // 이동 횟수 카운트
+
+        while (!queue.isEmpty()) {
+            int size = queue.size(); // 현재 레벨의 크기 (한 번의 주사위 던지기 결과)
+            count++;
+
+            // 현재 레벨에 있는 모든 노드 처리
+            for (int i = 0; i < size; i++) {
+                int current = queue.poll();
+
+                // 주사위 던지기 결과 (1부터 6까지)
+                for (int dice = 1; dice <= 6; dice++) {
+                    int next = current + dice;
+
+                    // 범위를 벗어난 경우는 무시
+                    if (next > 100) continue;
+
+                    // 사다리나 뱀에 의한 이동 처리
+                    if (arr[next] != 0) {
+                        next = arr[next];
+                    }
+
+                    // 목표 지점인 100에 도달하면 이동 횟수 리턴
+                    if (next == 100) {
+                        return count;
+                    }
+
+                    // 방문하지 않은 위치라면 큐에 추가
+                    if (!visited[next]) {
+                        visited[next] = true;
+                        queue.add(next);
+                    }
+                }
+            }
+        }
+
+        return -1; // 100에 도달할 수 없는 경우는 없으므로 사실상 이 부분은 필요 없음
+    }
+}
+
diff --git a/week11/BOJ11727.java b/week11/BOJ11727.java
new file mode 100644
index 0000000..e4d991d
--- /dev/null
+++ b/week11/BOJ11727.java
@@ -0,0 +1,25 @@
+package week11;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class BOJ11727 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int n = Integer.parseInt(br.readLine());
+
+		long[] arr = new long[1001];
+
+		arr[1] = 1; // 첫번째 경우
+		arr[2] = 3; // 두번째 경우
+
+		for (int i = 3; i <= n; i++) {
+			arr[i] = (arr[i - 1] + 2 * arr[i - 2]) % 10007; // 값이 크기 때문에 모듈러 연산
+		}
+
+		System.out.println(arr[n]);
+	}
+
+}
diff --git a/week11/BOJ1261.java b/week11/BOJ1261.java
new file mode 100644
index 0000000..4aa9904
--- /dev/null
+++ b/week11/BOJ1261.java
@@ -0,0 +1,80 @@
+package week11;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+public class BOJ1261 {
+
+	static class Node implements Comparable<Node> {
+		int y, x, weight;
+
+		public Node(int y, int x, int weight) {
+			super();
+			this.y = y;
+			this.x = x;
+			this.weight = weight;
+		}
+
+		@Override
+		public int compareTo(BOJ1261.Node o) {
+			return this.weight - o.weight;
+		}
+
+	}
+
+	static int[][] map, cmap;
+	static boolean[][] visited;
+	static int n, m;
+	static int[][] dir = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+			m = Integer.parseInt(st.nextToken());
+			n = Integer.parseInt(st.nextToken());
+
+			map = new int[n][m]; // 지도
+			cmap = new int[n][m]; // 값 저장할 지도
+			visited = new boolean[n][m];
+
+			for (int i = 0; i < n; i++) {
+				String str = br.readLine();
+				for (int j = 0; j < m; j++) {
+					map[i][j] = str.charAt(j) - '0'; // string으로 받아야해서 정수화
+					cmap[i][j] = Integer.MAX_VALUE/2;
+				}
+			}
+
+			dijkstra();
+			
+			System.out.println(cmap[n-1][m-1]);
+	}
+
+	static void dijkstra() { // 우선순위큐 활용한 다익스트라 사용
+		cmap[0][0] = map[0][0];
+		PriorityQueue<Node> pq = new PriorityQueue<>();
+		pq.add(new Node(0, 0, cmap[0][0]));
+		while (!pq.isEmpty()) {
+			Node cur = pq.poll();
+			if (visited[cur.y][cur.x])
+				continue;
+			visited[cur.y][cur.x] = true;
+
+			for (int i = 0; i < 4; i++) {
+				int dy = cur.y + dir[i][0];
+				int dx = cur.x + dir[i][1];
+
+				if (dy >= 0 && dy < n && dx >= 0 && dx < m) { // 4방탐색 하면서 값 갱신
+					if (cmap[dy][dx] > cmap[cur.y][cur.x] + map[dy][dx]) {
+						cmap[dy][dx] = cmap[cur.y][cur.x] + map[dy][dx];
+						pq.add(new Node(dy, dx, cmap[dy][dx]));
+					}
+				}
+			}
+		}
+	}
+
+}
diff --git a/week11/BOJ12865.java b/week11/BOJ12865.java
new file mode 100644
index 0000000..31a2230
--- /dev/null
+++ b/week11/BOJ12865.java
@@ -0,0 +1,41 @@
+package week11;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ12865 {
+
+	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 K = Integer.parseInt(st.nextToken()); // 최대무게
+
+		int[] weight = new int[N];
+		int[] value = new int[N];
+
+		for (int i = 0; i < N; i++) { // 입력부
+			st = new StringTokenizer(br.readLine());
+			weight[i] = Integer.parseInt(st.nextToken());
+			value[i] = Integer.parseInt(st.nextToken());
+		}
+
+        //dp[i][w] = i번째 물건까지 고려했을 때 w무게에서의 가치
+		int[][] dp = new int[N + 1][K + 1];
+
+		for (int i = 1; i <= N; i++) {
+			for (int w = 0; w <= K; w++) {
+				if (weight[i - 1] > w) { // 물품이 제한보다 무거운 경우
+					dp[i][w] = dp[i - 1][w];
+				} else { // 아닌 경우 넣거나 안넣거나 해서 값 계산
+					dp[i][w] = Math.max(dp[i - 1][w], dp[i - 1][w - weight[i - 1]] + value[i - 1]);
+				}
+			}
+		}
+
+		System.out.println(dp[N][K]);
+	}
+
+}
diff --git a/week11/BOJ2151.java b/week11/BOJ2151.java
new file mode 100644
index 0000000..e24061e
--- /dev/null
+++ b/week11/BOJ2151.java
@@ -0,0 +1,5 @@
+package week11;
+
+public class BOJ2151 {
+    
+}
diff --git a/week11/BOJ9251.java b/week11/BOJ9251.java
new file mode 100644
index 0000000..0d88e33
--- /dev/null
+++ b/week11/BOJ9251.java
@@ -0,0 +1,36 @@
+package week11;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class BOJ9251 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		String s1 = br.readLine();
+		String s2 = br.readLine();
+		
+		System.out.println(lcs(s1,s2));
+	}
+	
+	public static int lcs(String A, String B) {
+        int n = A.length();
+        int m = B.length();
+
+        int[][] dp = new int[n + 1][m + 1]; // 각 문자열 길이로 2차원 배열 만듬
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) { // 전부 탐색하면서
+                if (A.charAt(i - 1) == B.charAt(j - 1)) { // 같은 문자를 발견하면
+                    dp[i][j] = dp[i - 1][j - 1] + 1; // 대각선 위의 경우에서 + 1
+                } else { // 문자가 같지 않은 경우
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // 이전것들 중 큰것 선택
+                }
+            }
+        }
+        
+        return dp[n][m];
+    }
+
+}
diff --git a/week12/BOJ14938.java b/week12/BOJ14938.java
new file mode 100644
index 0000000..0ac1a79
--- /dev/null
+++ b/week12/BOJ14938.java
@@ -0,0 +1,101 @@
+package week12;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ14938 {
+
+	public static class Node implements Comparable<Node> { // node 클래스
+		int idx, weight;
+
+		public Node(int idx, int weight) {
+			super();
+			this.idx = idx;
+			this.weight = weight;
+		}
+
+		@Override
+		public int compareTo(BOJ14938.Node o) {
+			return this.weight - o.weight;
+		}
+
+	}
+
+	static int n, m, r, res;
+	static ArrayList<Node>[] graph;
+	static int[] item;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+		r = Integer.parseInt(st.nextToken());
+
+		graph = new ArrayList[n + 1];
+
+		for (int i = 0; i <= n; i++) {
+			graph[i] = new ArrayList<>();
+		}
+
+		item = new int[n + 1];
+		st = new StringTokenizer(br.readLine());
+		for (int i = 1; i <= n; i++) {
+			item[i] = Integer.parseInt(st.nextToken());
+		}
+
+		for (int i = 0; i < r; i++) {
+			st = new StringTokenizer(br.readLine());
+			int from = Integer.parseInt(st.nextToken());
+			int to = Integer.parseInt(st.nextToken());
+			int w = Integer.parseInt(st.nextToken());
+
+			graph[from].add(new Node(to, w)); // 무방향 그래프이므로 양쪽으로 다 사용
+			graph[to].add(new Node(from, w));
+		}
+		
+		for(int i=1;i<=n;i++) {
+			dijkstra(i);
+		}
+		
+		System.out.println(res);
+
+	}
+
+	static void dijkstra(int start) { // pq 를 사용한 다익스트라
+		Queue<Node> pq = new PriorityQueue<>();
+		boolean[] visited = new boolean[n + 1];
+		int[] dist = new int[n + 1];
+		Arrays.fill(dist, 20);
+		dist[start] = 0;
+		pq.offer(new Node(start, 0));
+		int tmp=0;
+
+		while (!pq.isEmpty()) {
+			int curidx = pq.poll().idx;
+			if (visited[curidx])
+				continue;
+
+			visited[curidx] = true;
+
+			for (Node n : graph[curidx]) {
+				if (dist[n.idx] > dist[curidx] + n.weight) {
+					dist[n.idx] = dist[curidx] + n.weight;
+
+					pq.offer(new Node(n.idx, dist[n.idx]));
+				}
+			}
+		}
+		
+		for(int i=1;i<=n;i++) {
+			if(dist[i]<=m) {
+				tmp+=item[i];
+			}
+		}
+
+		res = Math.max(res, tmp);
+	}
+}
+
diff --git a/week12/BOJ16236.java b/week12/BOJ16236.java
new file mode 100644
index 0000000..95cac96
--- /dev/null
+++ b/week12/BOJ16236.java
@@ -0,0 +1,111 @@
+package week12;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ16236 {
+
+	public static class Shark { // 상어 정보 클래스
+		int y, x, size, eat;
+
+		public Shark(int y, int x, int size, int eat) {
+			this.y = y;
+			this.x = x;
+			this.size = size;
+			this.eat = eat;
+		}
+	}
+
+	static int[][] map; // 맵
+	static int n, res;
+	static boolean[][] visited; // 방문처리
+	static int[][] dir = { { -1, 0 }, { 0, -1 }, { 0, 1 }, { 1, 0 } };
+	static Shark s;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+
+		n = Integer.parseInt(br.readLine());
+		map = new int[n][n];
+
+		for (int i = 0; i < n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 0; j < n; j++) {
+				map[i][j] = Integer.parseInt(st.nextToken());
+				if (map[i][j] == 9) { // 상어 초기위치 처리
+					s = new Shark(i, j, 2, 0);
+					map[i][j] = 0;
+				}
+			}
+		}
+
+		while (true) { // 상어가 더이상 먹을 물고기가 없을 때 까지 반복 수행
+			int move = bfs();
+			if (move == -1) break; // 먹지 못한 경우
+
+			res += move;
+
+			if (s.size == s.eat) { // 상어가 충분히 먹으면 크기 증가
+				s.size++;
+				s.eat = 0;
+			}
+		}
+
+		System.out.println(res);
+	}
+
+	public static int bfs() {
+		Queue<int[]> list = new ArrayDeque<>();
+		visited = new boolean[n][n];
+		list.add(new int[] { s.y, s.x });
+		visited[s.y][s.x] = true;
+
+		List<int[]> targets = new ArrayList<>();
+		int step = 0;
+
+		while (!list.isEmpty()) {
+			int size = list.size();
+			step++;
+
+			for (int i = 0; i < size; i++) {
+				int[] cur = list.poll();
+
+				for (int d = 0; d < 4; d++) {
+					int dy = cur[0] + dir[d][0];
+					int dx = cur[1] + dir[d][1];
+
+					if (dy >= 0 && dy < n && dx >= 0 && dx < n && !visited[dy][dx]) {
+						if (map[dy][dx] <= s.size) { // 이동 가능한 경우 이동
+							visited[dy][dx] = true;
+
+							if (map[dy][dx] != 0 && map[dy][dx] < s.size) {
+								targets.add(new int[] { dy, dx }); // 물고기인 경우 먹을 수 있는 물고기 후보 처리
+							}
+
+							list.add(new int[] { dy, dx });
+						}
+					}
+				}
+			}
+
+			if (!targets.isEmpty()) { // 먹이 우선순위에 따라 물고기 먹는 칸 구하기
+				targets.sort((a, b) -> {
+					if (a[0] != b[0]) return a[0] - b[0]; // 위쪽
+					return a[1] - b[1]; // 왼쪽
+				});
+
+				int[] target = targets.get(0);
+				s.y = target[0];
+				s.x = target[1];
+				s.eat++; // 먹은 횟수 증가
+				map[s.y][s.x] = 0; // 먹은 물고기 칸 0으로 수정
+				return step;
+			}
+		}
+
+		return -1;
+	}
+}
+
diff --git a/week12/BOJ17086.java b/week12/BOJ17086.java
new file mode 100644
index 0000000..9930475
--- /dev/null
+++ b/week12/BOJ17086.java
@@ -0,0 +1,74 @@
+package week12;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ17086 {
+
+	static int[][] map;
+	static int n, m, dist;
+	static boolean[][] visited;
+	static int[][] dir = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 }, { -1, -1 }, { -1, 1 }, { 1, -1 }, { 1, 1 } };
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+
+		map = new int[n][m];
+
+		for (int i = 0; i < n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 0; j < m; j++) {
+				map[i][j] = Integer.parseInt(st.nextToken());
+			}
+		}
+
+		dist = Integer.MIN_VALUE;
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; j++) {
+				if (map[i][j] == 0) { // 상어가 없는 곳 마다 bfs 수행하여 안전거리 구함
+					bfs(new int[] { i, j });
+				}
+			}
+		}
+
+		System.out.println(dist);
+	}
+
+	public static void bfs(int[] start) {
+		Queue<int[]> list = new ArrayDeque<>();
+		visited = new boolean[n][m];
+		visited[start[0]][start[1]] = true;
+		list.add(start);
+		int step = 1; // step 별 bfs 수행으로 상어를 만나면 step을 안전거리로 갱신
+
+		while (!list.isEmpty()) {
+			int size = list.size();
+			for (int s = 0; s < size; s++) {
+				int[] cur = list.poll();
+				for (int i = 0; i < 8; i++) {
+					int dy = cur[0] + dir[i][0];
+					int dx = cur[1] + dir[i][1];
+
+					if (dy >= 0 && dy < n && dx >= 0 && dx < m) {
+						if (map[dy][dx] == 1) {
+							dist = Math.max(dist, step);
+							return;
+						} else if (!visited[dy][dx]) {
+							visited[dy][dx] = true;
+							list.add(new int[] { dy, dx });
+						}
+					}
+				}
+			}
+			step++;
+		}
+	}
+}
+
diff --git a/week12/BOJ2293.java b/week12/BOJ2293.java
new file mode 100644
index 0000000..a4fc255
--- /dev/null
+++ b/week12/BOJ2293.java
@@ -0,0 +1,35 @@
+package week12;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ2293 {
+
+    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 max = Integer.parseInt(st.nextToken());
+            int[] val = new int[max + 1]; // 1원부터 세기 위해서 +1로 배열
+            int[] coin = new int[n];
+
+            for (int i = 0; i < n; i++) { // 동전 가격
+                coin[i] = Integer.parseInt(br.readLine());
+            }
+
+
+            val[0] = 1;
+
+            for (int i = 0; i < n; i++) {
+                for (int j = coin[i]; j <= max; j++) { // 가장 낮은 가격부터
+                    val[j] += val[j - coin[i]]; //dp 계산
+                }
+            }
+
+            System.out.println(val[max]);
+        
+    }
+}
+
diff --git a/week12/BOJ9461.java b/week12/BOJ9461.java
new file mode 100644
index 0000000..98e58db
--- /dev/null
+++ b/week12/BOJ9461.java
@@ -0,0 +1,23 @@
+package week12;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class BOJ9461 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int T = Integer.parseInt(br.readLine());
+		long[] pado = new long[101];
+		pado[1] = pado[2] = pado[3] = 1;
+		for (int i = 4; i <= 100; i++) {
+			pado[i] = pado[i - 2] + pado[i - 3];
+		}
+
+		for (int t = 0; t < T; t++) {
+			System.out.println(pado[Integer.parseInt(br.readLine())]);
+		}
+	}
+}
+
diff --git a/week13/BOJ13549.java b/week13/BOJ13549.java
new file mode 100644
index 0000000..9b22c90
--- /dev/null
+++ b/week13/BOJ13549.java
@@ -0,0 +1,66 @@
+package week13;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ13549 {
+
+	static class Node implements Comparable<Node> {
+		int x, time;
+
+		public Node(int x, int time) {
+			super();
+			this.x = x;
+			this.time = time;
+		}
+
+		@Override
+		public int compareTo(BOJ13549.Node o) {
+			return this.time - o.time;
+		}
+
+	}
+
+	static int n, k;
+	static Queue<Node> list = new PriorityQueue<>();
+	static boolean[] visited;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		k = Integer.parseInt(st.nextToken());
+		visited = new boolean[1000001];
+		list.add(new Node(n, 0));
+
+		bfs();
+	}
+
+	static void bfs() { // bfs처럼 탐색하면서 찾기
+		while (!list.isEmpty()) {
+			Node cur = list.poll();
+			if (visited[cur.x])
+				continue;
+			visited[cur.x] = true;
+
+			if (cur.x == k) {
+				System.out.println(cur.time);
+				return;
+			}
+			int dx = cur.x * 2;
+			if (dx <= 100000 && !visited[dx]) {
+				list.add(new Node(dx, cur.time));
+			}
+			dx = cur.x - 1;
+			if (dx >= 0 && !visited[dx]) {
+				list.add(new Node(dx, cur.time + 1));
+			}
+			dx = cur.x + 1;
+			if (dx <= 100000 && !visited[dx]) {
+				list.add(new Node(dx, cur.time + 1));
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/week13/BOJ1629.java b/week13/BOJ1629.java
new file mode 100644
index 0000000..0e119bb
--- /dev/null
+++ b/week13/BOJ1629.java
@@ -0,0 +1,31 @@
+package week13;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ1629 {
+
+	static int MOD;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		int a = Integer.parseInt(st.nextToken());
+		int b = Integer.parseInt(st.nextToken());
+		MOD = Integer.parseInt(st.nextToken());
+
+		System.out.println(pow(a, b));
+
+	}
+
+	static long pow(long a, int b) { // 큰 수 제곱 방식 활용
+		if (b == 0)
+			return 1;
+		long half = pow(a, b / 2);
+		long result = (half * half) % MOD;
+		if (b % 2 == 1)
+			result = (result * a) % MOD;
+		return result;
+	}
+}
\ No newline at end of file
diff --git a/week13/BOJ1918.java b/week13/BOJ1918.java
new file mode 100644
index 0000000..8ea794e
--- /dev/null
+++ b/week13/BOJ1918.java
@@ -0,0 +1,61 @@
+package week13;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ1918 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+
+		String str = br.readLine();
+
+		System.out.println(topostfix(str));
+	}
+
+	static String topostfix(String str) {
+		StringBuilder sb = new StringBuilder();
+		Stack<Character> stack = new Stack<>();
+
+		for (char c : str.toCharArray()) {
+			if (isAlphabet(c)) { // 알파벳이면 바로 입력
+				sb.append(c);
+			} else if (c == '(') { // 여는 괄호 나오면 스택에 저장
+				stack.push(c);
+			} else if (c == ')') { // 닫는 괄호 나오면
+				while (!stack.isEmpty() && stack.peek() != '(') { // 여는 괄호 전까지
+					sb.append(stack.pop()); // 스택에서 빼서 입력
+				}
+				stack.pop();
+			} else if (isOperater(c)) { // 연산자인 경우
+				while (!stack.isEmpty() && priority(stack.peek()) >= priority(c)) {
+					sb.append(stack.pop()); // 스택에 들어있는 연산자가 현재 연산자보다 우선순위가 높으면 스택에서 꺼내서 입력
+				}
+				stack.push(c); // 연산자를 스택에 저장
+			}
+		}
+
+		while (!stack.isEmpty()) {
+			sb.append(stack.pop()); // 나머지 연산자 후위표기로 입력
+		}
+
+		return sb.toString();
+	}
+
+	static boolean isAlphabet(char c) { // 알파벳 대문자가 숫자 대용이므로 판단
+		return c - 'A' >= 0 && c - 'A' <= 26;
+	}
+
+	static boolean isOperater(char c) { // 연산자인지 판단
+		return c == '*' || c == '/' || c == '+' || c == '-';
+	}
+
+	static int priority(char c) { // 연산자 우선순위 판단
+		if (c == '+' || c == '-')
+			return 1;
+		if (c == '/' || c == '*')
+			return 2;
+		return 0;
+	}
+}
diff --git a/week13/BOJ2206.java b/week13/BOJ2206.java
new file mode 100644
index 0000000..d9bc73d
--- /dev/null
+++ b/week13/BOJ2206.java
@@ -0,0 +1,78 @@
+package week13;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ2206 {
+
+	static int n, m;
+	static int[][] map;
+	static boolean[][][] visited;
+	static int[][] dir = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
+
+	static class Cell {
+		int y, x, wall;
+
+		public Cell(int y, int x, int wall) {
+			super();
+			this.y = y;
+			this.x = x;
+			this.wall = wall;
+		}
+
+	}
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+
+		map = new int[n][m];
+		visited = new boolean[n][m][2];
+
+		for (int i = 0; i < n; i++) {
+			String str = br.readLine();
+			for (int j = 0; j < m; j++) {
+				map[i][j] = str.charAt(j) - '0';
+			}
+		}
+		
+		bfs();
+	}
+
+	static void bfs() {
+		Queue<Cell> list = new ArrayDeque<>();
+		list.add(new Cell(0, 0, 0));
+		visited[0][0][0] = true;
+		int step = 1;
+
+		while (!list.isEmpty()) {
+			int size = list.size();
+			for (int s = 0; s < size; s++) {
+				Cell cur = list.poll();
+				if (cur.y == n - 1 && cur.x == m - 1) {
+					System.out.println(step);
+					return;
+				}
+				for (int d = 0; d < 4; d++) {
+					int dy = cur.y + dir[d][0];
+					int dx = cur.x + dir[d][1];
+					if (dy >= 0 && dy < n && dx >= 0 && dx < m) {
+						if (map[dy][dx] == 1 && cur.wall == 0 && !visited[dy][dx][1]) {
+							visited[dy][dx][1] = true;
+							list.add(new Cell(dy, dx, 1));
+						} else if (map[dy][dx] == 0 && !visited[dy][dx][cur.wall]) {
+							visited[dy][dx][cur.wall] = true;
+							list.add(new Cell(dy, dx, cur.wall));
+						}
+					}
+				}
+			}
+			step++;
+		}
+		System.out.println("-1");
+	}
+
+}
diff --git a/week13/BOJ9465.java b/week13/BOJ9465.java
new file mode 100644
index 0000000..6eedc97
--- /dev/null
+++ b/week13/BOJ9465.java
@@ -0,0 +1,55 @@
+package week13;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ9465 {
+
+	static int n;
+	static int[][] sticker;
+	static int[][] dp;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+		StringBuilder sb = new StringBuilder();
+		int T = Integer.parseInt(br.readLine());
+
+		for (int t = 1; t <= T; t++) {
+			n = Integer.parseInt(br.readLine());
+			sticker = new int[2][n];
+			dp = new int[2][n];
+
+			for (int i = 0; i < 2; i++) { // 스티커입력
+				st = new StringTokenizer(br.readLine());
+				for (int j = 0; j < n; j++) {
+					sticker[i][j] = Integer.parseInt(st.nextToken());
+				}
+			}
+
+			if (n == 1) { // 1칸짜리 일 경우
+				sb.append(Math.max(sticker[0][0], sticker[1][0]) + "\n");
+				continue;
+			}
+
+			else { // 2칸 이상인 경우
+				dp[0][0] = sticker[0][0];
+				dp[1][0] = sticker[1][0];
+
+				dp[0][1] = dp[1][0] + sticker[0][1];
+				dp[1][1] = dp[0][0] + sticker[1][1];
+
+				for (int i = 2; i < n; i++) { // dp 계산
+					for (int j = 0; j < 2; j++) {
+						dp[j][i] += Math.max(dp[(j * -1) + 1][i - 1], dp[(j * -1) + 1][i - 2]);
+						dp[j][i] += sticker[j][i];
+					}
+				}
+
+				sb.append(Math.max(dp[0][n - 1], dp[1][n - 1]) + "\n");
+			}
+		}
+
+		System.out.println(sb);
+	}
+}
diff --git a/week14/BOJ14503.java b/week14/BOJ14503.java
new file mode 100644
index 0000000..e17a24e
--- /dev/null
+++ b/week14/BOJ14503.java
@@ -0,0 +1,97 @@
+package week14;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ14503 {
+
+	static int n, m, res;
+	static int[][] map;
+	static int[][] dir = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
+	static int[] turn = { 3, 0, 1, 2 }; // 왼쪽으로 90도 도는 경우
+	static int[] round = { 2, 3, 0, 1 }; // 뒤로 가는 경우
+
+	static class cleaner { // 청소기 클래스
+		int y, x, dir;
+
+		public cleaner(int y, int x, int dir) {
+			super();
+			this.y = y;
+			this.x = x;
+			this.dir = dir;
+		}
+
+	}
+
+	static cleaner c;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+
+		map = new int[n][m];
+
+		st = new StringTokenizer(br.readLine());
+		int y = Integer.parseInt(st.nextToken());
+		int x = Integer.parseInt(st.nextToken());
+		int d = Integer.parseInt(st.nextToken());
+		c = new cleaner(y, x, d);
+
+		for (int i = 0; i < n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 0; j < m; j++) {
+				map[i][j] = Integer.parseInt(st.nextToken());
+			}
+		}
+		
+		run();
+		System.out.println(res);
+	}
+
+	static void run() {
+		while (true) {
+			if (map[c.y][c.x] == 0) {
+				map[c.y][c.x] = 2;
+				res++;
+			}
+
+			boolean chk = false;
+
+			for (int d = 0; d < 4; d++) { // 4방향 중 청소할 곳 있는지 탐색
+				int dy = c.y + dir[d][0];
+				int dx = c.x + dir[d][1];
+				if (dy < 0 || dy >= n || dx < 0 || dx >= m)
+					continue;
+				if (map[dy][dx] == 0) {
+					chk = true;
+					break;
+				}
+			}
+			if (chk) { // 청소할 곳이 있다면 왼쪽으로 90도 돌아서 확인
+				c.dir = turn[c.dir];
+				int dy = c.y + dir[c.dir][0];
+				int dx = c.x + dir[c.dir][1];
+				if (dy < 0 || dy >= n || dx < 0 || dx >= m)
+					continue;
+				if (map[dy][dx] == 0) {
+					c.y = dy;
+					c.x = dx;
+				}
+			} else { // 청소할 곳이 없다면 뒤로 한칸 이동
+				int dy = c.y + dir[round[c.dir]][0];
+				int dx = c.x + dir[round[c.dir]][1];
+				if (dy < 0 || dy >= n || dx < 0 || dx >= m || map[dy][dx] == 1)
+					return;
+				else {
+					c.y = dy;
+					c.x = dx;
+				}
+			}
+		}
+	}
+
+}
+
diff --git a/week14/BOJ1699.java b/week14/BOJ1699.java
new file mode 100644
index 0000000..1238480
--- /dev/null
+++ b/week14/BOJ1699.java
@@ -0,0 +1,32 @@
+package week14;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ1699 {
+
+    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[] dp = new int[100001]; // 최대 10만까지 고려함
+        dp[0] = 0;
+        dp[1] = 1;
+        dp[2] = 2;
+        dp[3] = 3;
+
+        for (int i = 4; i <= n; i++) {
+            dp[i] = i;
+            for (int j = 1; j * j <= i; j++) { // 제곱수 이전이 있다면 그 이전꺼 + 제곱수 1개
+                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
+            }
+        }
+
+        System.out.println(dp[n]);
+
+    }
+
+}
diff --git a/week14/BOJ17142.java b/week14/BOJ17142.java
new file mode 100644
index 0000000..6b2fb97
--- /dev/null
+++ b/week14/BOJ17142.java
@@ -0,0 +1,113 @@
+package week14;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ17142 {
+
+	static int n, v, m, res;
+	static List<int[]> virus = new ArrayList<>();
+	static int[][] map;
+	static Queue<int[]> q = new ArrayDeque<>();
+	static int[][] dir = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
+	static int[] num;
+	static final int INF = 1000000;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+		res = INF;
+		map = new int[n][n];
+		num = new int[m];
+		int cntzero = 0;
+
+		for (int i = 0; i < n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 0; j < n; j++) {
+				int a = Integer.parseInt(st.nextToken());
+				if (a == 2) {
+					virus.add(new int[] { i, j });
+					v++; // 바이러스의 총 수
+				}
+				if (a == 0)
+					cntzero++; // 감염시켜야할 칸 수
+				map[i][j] = a;
+			}
+		}
+
+		if (cntzero == 0) // 감염시킬 칸이 없는 경우 0 출력
+			System.out.println("0");
+		else {
+
+			combination(0, 0);
+
+			if (res == INF)
+				System.out.println("-1");
+			else
+				System.out.println(res);
+		}
+	}
+
+	static void bfs(boolean[][] visited, Queue<int[]> q) {
+	    int[][] time = new int[n][n]; // 각 칸별 감염되는 시간을 저장할 배열
+	    int max = 0;
+
+	    while (!q.isEmpty()) {
+	        int[] cur = q.poll();
+	        for (int d = 0; d < 4; d++) {
+	            int dy = cur[0] + dir[d][0];
+	            int dx = cur[1] + dir[d][1];
+
+	            if (dy >= 0 && dy < n && dx >= 0 && dx < n && map[dy][dx] != 1 && !visited[dy][dx]) {
+	                visited[dy][dx] = true; // 감염 가능한 구역을 찾아서 감염시키고 시간 저장
+	                time[dy][dx] = time[cur[0]][cur[1]] + 1;
+	                q.add(new int[] { dy, dx });
+	            }
+	        }
+	    }
+
+        // 모든 탐색이 끝나면 전 지역을 감염시켰는지 확인
+	    boolean success = true;
+	    for (int i = 0; i < n; i++) {
+	        for (int j = 0; j < n; j++) {
+	            if (map[i][j] == 0) {
+	                if (!visited[i][j]) {
+	                    success = false;
+	                    break;
+	                } else {
+	                    max = Math.max(max, time[i][j]);
+	                }
+	            }
+	        }
+	    }
+
+	    if (success) { // 모두 감염 시켰다면 res 갱신
+	        res = Math.min(res, max);
+	    }
+	}
+
+
+	static void combination(int cnt, int start) { // 처음 활성화시키는 바이러스 조합 구하고 탐색
+		if (cnt == m) {
+			boolean[][] visited = new boolean[n][n];
+			Queue<int[]> q = new ArrayDeque<>();
+			for (int i = 0; i < m; i++) {
+				int[] cur = virus.get(num[i]);
+				visited[cur[0]][cur[1]] = true;
+				q.add(cur);
+			}
+			bfs(visited, q);
+			return;
+		}
+
+		for (int i = start; i < virus.size(); i++) {
+			num[cnt] = i;
+			combination(cnt + 1, i + 1);
+		}
+	}
+
+}
+
diff --git a/week14/BOJ2133.java b/week14/BOJ2133.java
new file mode 100644
index 0000000..ea26b66
--- /dev/null
+++ b/week14/BOJ2133.java
@@ -0,0 +1,31 @@
+package week14;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ2133 {
+
+	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[] dp = new int[31]; // 최대 30칸 까지
+		dp[0] = 1;
+		dp[1] = 0;
+		dp[2] = 3;
+
+		for (int i = 4; i <= n; i += 2) { // 점화식을 이용한 dp 풀이
+			dp[i] = 3 * dp[i - 2];
+			for (int j = 4; j <= i; j += 2) {
+				dp[i] += 2 * dp[i - j];
+			}
+		}
+
+		System.out.println(dp[n]);
+
+	}
+
+}
+
diff --git a/week14/BOJ2629.java b/week14/BOJ2629.java
new file mode 100644
index 0000000..61858be
--- /dev/null
+++ b/week14/BOJ2629.java
@@ -0,0 +1,59 @@
+package week14;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ2629 {
+
+	static int n, m, res;
+	static int[] w;
+	static boolean[][] chk;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+		StringBuilder sb = new StringBuilder();
+
+		n = Integer.parseInt(br.readLine());
+		w = new int[n];
+		st = new StringTokenizer(br.readLine());
+
+		for (int i = 0; i < n; i++) {
+			w[i] = Integer.parseInt(st.nextToken()); // 추 무들
+		}
+
+		m = Integer.parseInt(br.readLine());
+		chk = new boolean[n + 1][15001];
+
+		dfs(0, 0);
+
+		st = new StringTokenizer(br.readLine());
+		for (int i = 0; i < m; i++) {
+			res = Integer.parseInt(st.nextToken()); // 구슬 무게를 그때그때 받아서 판단
+			if (res > 15001) {
+				sb.append("N ");
+				continue;
+			}
+			if (chk[n][res])
+				sb.append("Y ");
+			else
+				sb.append("N ");
+		}
+		System.out.println(sb);
+	}
+
+	static void dfs(int cnt, int weight) {
+		if (cnt > n || weight < 0 || weight > 15001 || chk[cnt][weight])
+			return;
+
+		chk[cnt][weight] = true; // cnt 번째까지의 추를 고려했을 때의 가능한 무게
+
+		if (cnt == n)
+			return;
+
+		dfs(cnt + 1, weight + w[cnt]); // 추를 올리거나
+		dfs(cnt + 1, weight); // 추를 사용하지 않거나
+		dfs(cnt + 1, Math.abs(weight - w[cnt])); // 추를 구슬쪽에 올리거나
+	}
+}
+
diff --git a/week15/BOJ14719.java b/week15/BOJ14719.java
new file mode 100644
index 0000000..f2f48bb
--- /dev/null
+++ b/week15/BOJ14719.java
@@ -0,0 +1,46 @@
+package week15;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ14719 {
+	
+	static int[] height;
+	static int n,m,result;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        height = new int[m];
+        
+        st = new StringTokenizer(br.readLine());
+        for(int i=0;i<m;i++) {
+        	height[i] = Integer.parseInt(st.nextToken());
+        }
+        
+        int[] left = new int[m]; // 각 위치의 왼쪽 벽 높이
+        int[] right = new int[m]; // 각 위치의 오른쪽 벽 높이
+        
+        left[0]=height[0];
+        for(int i=1;i<m;i++) { // 왼쪽 벽 높이 계산
+        	left[i] = Math.max(left[i-1], height[i]);
+        }
+        right[m-1]=height[m-1];
+        for(int i=m-2;i>=0;i--) { // 오른쪽 벽 높이 계산
+        	right[i] = Math.max(right[i+1], height[i]);
+        }
+        
+        for(int i=0;i<m;i++) { // 두 벽 중 낮은 곳으로 각 위치의 물 양 계산
+        	int water = Math.min(left[i], right[i]) - height[i];
+        	if(water>0)
+        		result+=water;
+        }
+        
+        System.out.println(result);
+    }
+
+}
+
diff --git a/week15/BOJ15683.java b/week15/BOJ15683.java
new file mode 100644
index 0000000..0723ef1
--- /dev/null
+++ b/week15/BOJ15683.java
@@ -0,0 +1,118 @@
+package week15;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ15683 {
+
+    static class camera { // 카메라 정보 저장 클래스
+        int y, x, type;
+
+        public camera(int y, int x, int type) {
+            this.y = y;
+            this.x = x;
+            this.type = type;
+        }
+    }
+
+    static int n, m, result;
+    static int[][] maps;
+    static List<camera> cams = new ArrayList<>();
+    static int[][] dir = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        maps = new int[n][m];
+        result = Integer.MAX_VALUE;
+
+        for (int i = 0; i < n; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < m; j++) {
+                int a = Integer.parseInt(st.nextToken());
+                maps[i][j] = a;
+                if (a >= 1 && a <= 5) {
+                    cams.add(new camera(i, j, a));
+                }
+            }
+        }
+
+        simulate(0, maps);
+
+        System.out.println(result);
+    }
+
+    static void simulate(int idx, int[][] map) {
+        if (idx == cams.size()) { // 카메라 다 확인한 경우
+            int tmp = 0;
+            for (int i = 0; i < n; i++) { // 사각지대 체크
+                for (int j = 0; j < m; j++) {
+                    if (map[i][j] == 0) {
+                        tmp++;
+                    }
+                }
+            }
+            result = Math.min(result, tmp); // 최소값으로 갱신
+            return;
+        }
+
+        camera c = cams.get(idx);
+        int[][] backup = copy(map); // 백트래킹위해 현재 상태 따로 저장
+
+        for (int d = 0; d < 4; d++) { // 카메라 1,3,4의 경우에는 4번 시행
+            watch(c, map, d);		  // 카메라 2의 경우 2번 시행, 5는 1번 시행
+            simulate(idx + 1, map);
+            map = copy(backup);
+            if (c.type == 2 && d == 1) break;
+            if (c.type == 5) break;
+        }
+    }
+
+    static void watch(camera c, int[][] map, int direction) {
+        int type = c.type;
+        int y = c.y;
+        int x = c.x;
+
+        if (type == 1) { // 1방향
+            observe(map, y, x, direction);
+        } else if (type == 2) { // 양방향 반대로
+            observe(map, y, x, direction);
+            observe(map, y, x, (direction + 2) % 4);
+        } else if (type == 3) { // 양방향 직각으로
+            observe(map, y, x, direction);
+            observe(map, y, x, (direction + 1) % 4);
+        } else if (type == 4) { // 3방향
+            observe(map, y, x, direction);
+            observe(map, y, x, (direction + 1) % 4);
+            observe(map, y, x, (direction + 2) % 4);
+        } else if (type == 5) { // 4방향
+            for (int d = 0; d < 4; d++) {
+                observe(map, y, x, d);
+            }
+        }
+    }
+
+    static void observe(int[][] map, int y, int x, int d) {
+        int ny = y + dir[d][0];
+        int nx = x + dir[d][1];
+
+        while (ny >= 0 && ny < n && nx >= 0 && nx < m) { // 맵 끝이나 벽까지 감시
+            if (map[ny][nx] == 6) break;
+            if (map[ny][nx] == 0) map[ny][nx] = 7;
+            ny += dir[d][0];
+            nx += dir[d][1];
+        }
+    }
+
+    static int[][] copy(int[][] origin) { // 맵 복사 메소드
+        int[][] tmp = new int[n][m];
+        for (int i = 0; i < n; i++) {
+            tmp[i] = origin[i].clone();
+        }
+        return tmp;
+    }
+}
+
diff --git a/week15/BOJ16173.java b/week15/BOJ16173.java
new file mode 100644
index 0000000..9ed498f
--- /dev/null
+++ b/week15/BOJ16173.java
@@ -0,0 +1,50 @@
+package week15;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ16173 {
+
+	static int N;
+    static int[][] map;
+    static boolean[][] visited;
+    static boolean found = false;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        
+        N = Integer.parseInt(br.readLine());
+        map = new int[N][N];
+        visited = new boolean[N][N];
+
+        for (int i = 0; i < N; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < N; j++) {
+                map[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        dfs(0, 0);
+
+        System.out.println(found ? "HaruHaru" : "Hing");
+    }
+
+    public static void dfs(int x, int y) {
+        if (x < 0 || y < 0 || x >= N || y >= N || visited[x][y]) {
+            return; // 이동 가능 유효성 검사
+        }
+
+        visited[x][y] = true;
+
+        if (map[x][y] == -1) {
+            found = true;
+            return;
+        }
+
+        int jump = map[x][y];
+        dfs(x + jump, y); // 아래 이동
+        dfs(x, y + jump); // 오른쪽 이동
+    }
+}
+
diff --git a/week15/BOJ20056.java b/week15/BOJ20056.java
new file mode 100644
index 0000000..a405f95
--- /dev/null
+++ b/week15/BOJ20056.java
@@ -0,0 +1,99 @@
+package week15;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ20056 {
+    static class Fireball {
+        int r, c, m, s, d;
+
+        public Fireball(int r, int c, int m, int s, int d) {
+            this.r = r;
+            this.c = c;
+            this.m = m;
+            this.s = s;
+            this.d = d;
+        }
+    }
+
+    static int N, M, K;
+    static List<Fireball>[][] map;
+    static int[] dr = {-1, -1, 0, 1, 1, 1, 0, -1};
+    static int[] dc = {0, 1, 1, 1, 0, -1, -1, -1};
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());  // 격자 크기
+        M = Integer.parseInt(st.nextToken());  // 파이어볼 개수
+        K = Integer.parseInt(st.nextToken());  // 명령 횟수
+
+        map = new ArrayList[N][N];
+        for (int i = 0; i < N; i++)
+            for (int j = 0; j < N; j++)
+                map[i][j] = new ArrayList<>();
+
+        List<Fireball> fireballs = new ArrayList<>();
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            int r = Integer.parseInt(st.nextToken()) - 1;
+            int c = Integer.parseInt(st.nextToken()) - 1;
+            int m = Integer.parseInt(st.nextToken());
+            int s = Integer.parseInt(st.nextToken());
+            int d = Integer.parseInt(st.nextToken());
+            fireballs.add(new Fireball(r, c, m, s, d));
+        }
+
+        while (K-- > 0) {
+            // 파이어볼 이동
+            for (Fireball fb : fireballs) {
+                int nr = (fb.r + dr[fb.d] * fb.s % N + N) % N;
+                int nc = (fb.c + dc[fb.d] * fb.s % N + N) % N;
+                map[nr][nc].add(new Fireball(nr, nc, fb.m, fb.s, fb.d));
+            }
+
+            // 처리
+            fireballs.clear();
+            for (int r = 0; r < N; r++) {
+                for (int c = 0; c < N; c++) {
+                    if (map[r][c].size() == 0) continue;
+
+                    if (map[r][c].size() == 1) {
+                        fireballs.add(map[r][c].get(0));
+                    } else {
+                        int sumM = 0, sumS = 0;
+                        boolean allEven = true, allOdd = true;
+
+                        for (Fireball fb : map[r][c]) {
+                            sumM += fb.m;
+                            sumS += fb.s;
+                            if (fb.d % 2 == 0) allOdd = false;
+                            else allEven = false;
+                        }
+
+                        int newM = sumM / 5;
+                        if (newM == 0) {
+                            map[r][c].clear();
+                            continue;
+                        }
+
+                        int newS = sumS / map[r][c].size();
+                        int[] newDirs = (allEven || allOdd) ? new int[]{0, 2, 4, 6} : new int[]{1, 3, 5, 7};
+                        for (int d : newDirs) {
+                            fireballs.add(new Fireball(r, c, newM, newS, d));
+                        }
+                    }
+                    map[r][c].clear();
+                }
+            }
+        }
+
+        int answer = 0;
+        for (Fireball fb : fireballs) {
+            answer += fb.m;
+        }
+        System.out.println(answer);
+    }
+}
+
diff --git a/week16/BOJ10157.java b/week16/BOJ10157.java
new file mode 100644
index 0000000..a82d80d
--- /dev/null
+++ b/week16/BOJ10157.java
@@ -0,0 +1,61 @@
+package week16;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ10157 {
+
+	static boolean[][] map;
+	static int n, m, num;
+	static int[][] dir = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+
+		map = new boolean[m][n];
+		
+		int count = n*m;
+		int cnt = 1;
+		num = Integer.parseInt(br.readLine());
+		
+		int y = m-1; // 배열로 했을 때 왼쪽 하단에서 시작하기 때문에 좌표 맞춰줌
+		int x = 0;
+		map[y][x] = true;
+		int dnum = 0;
+		while(cnt<=count) {
+			if(cnt==num) { // 번호 도착한 경우 출력하고 종료
+				System.out.println((x+1) + " " + (m-y));
+				return;
+			}
+			if(cnt==count)
+				break;
+			int dy = y + dir[dnum][0];
+			int dx = x + dir[dnum][1];
+			
+            // 달팽이 모양으로 돌기 위한 조건들
+			if(dy<0||dy>=m||dx<0||dx>=n) { // 임계점이거나
+				dnum++;
+				dnum = dnum%4;
+				continue;
+			}
+			if(map[dy][dx]) { // 이미 방문한 곳을 만나면 방향 전환
+				dnum++;
+				dnum = dnum%4;
+				continue;
+			}
+			map[dy][dx]=true;
+			y=dy;
+			x=dx;
+			
+			cnt++;
+		}
+		
+		System.out.println("0"); // 못 앉는 경우
+	}
+
+}
+
diff --git a/week16/BOJ1459.java b/week16/BOJ1459.java
new file mode 100644
index 0000000..90fbe87
--- /dev/null
+++ b/week16/BOJ1459.java
@@ -0,0 +1,46 @@
+package week16;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ1459 {
+
+	static long x, y, w, s, res; // 수가 크기 때문에 long 사용
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		x = Integer.parseInt(st.nextToken());
+		y = Integer.parseInt(st.nextToken());
+		w = Integer.parseInt(st.nextToken());
+		s = Integer.parseInt(st.nextToken());
+
+		long height = Math.min(x, y); // 세로 거리
+
+		if (s <= 2 * w) { // 대각선이 이득인 경우
+			res += s * height;
+		} else {
+			res += w * 2 * height;
+		}
+
+		long width = Math.max(x, y) - Math.min(x, y); // 가로 거리
+		if (width % 2 == 0) { // 남은 거리가 짝수일 때
+			if (2 * s <= 2 * w) { // 지그재그가 이득인 경우
+				res += 2 * s * (width / 2);
+			} else { // 직선 이동이 이득인 경우
+				res += w * width;
+			}
+		} else { // 남은 거리가 홀수일 때
+			if (2 * s <= 2 * w) { 
+				res += 2 * s * (width / 2);
+				res += w;
+			} else {
+				res += w * width;
+			}
+		}
+
+		System.out.println(res);
+	}
+
+}
diff --git a/week16/BOJ18111.java b/week16/BOJ18111.java
new file mode 100644
index 0000000..619345a
--- /dev/null
+++ b/week16/BOJ18111.java
@@ -0,0 +1,57 @@
+package week16;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ18111 {
+
+	static int n, m, b;
+	static int[][] map;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+		b = Integer.parseInt(st.nextToken());
+
+		map = new int[n][m];
+
+		for (int i = 0; i < n; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 0; j < m; j++) {
+				int a = Integer.parseInt(st.nextToken());
+				map[i][j] = a;
+			}
+		}
+
+		int restime = Integer.MAX_VALUE;
+		int resh = 0;
+
+		for (int h = 0; h <= 256; h++) { // 높이를 가능한 경우 모두 탐색
+			int remove = 0;
+			int place = 0;
+
+			for (int i = 0; i < n; i++) {
+				for (int j = 0; j < m; j++) {
+					if (map[i][j] > h) {
+						remove += map[i][j] - h; // 부셔야 되는 경우 횟수
+					} else {
+						place += h - map[i][j]; // 설치해야 되는 경우 횟수
+					}
+				}
+			}
+
+			if (remove + b >= place) { // 시간 계산
+				int time = remove * 2 + place;
+				if (time <= restime) {
+					restime = time;
+					resh = h;
+				}
+			}
+		}
+		System.out.println(restime + " " + resh);
+	}
+}
+
diff --git a/week16/BOJ2578.java b/week16/BOJ2578.java
new file mode 100644
index 0000000..66053a6
--- /dev/null
+++ b/week16/BOJ2578.java
@@ -0,0 +1,72 @@
+package week16;
+
+import java.io.*;
+import java.util.*;
+
+public class BOJ2578 {
+
+	static Map<Integer, int[]> list = new HashMap<>();
+	static int[] x = new int[6];
+	static int[] y = new int[6];
+	static int[] diagonal = new int[2];
+	static boolean[] x_done = new boolean[6];
+	static boolean[] y_done = new boolean[6];
+	static boolean[] d_done = new boolean[2];
+	static int bingo = 0;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+
+		for (int i = 1; i <= 5; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 1; j <= 5; j++) {
+				int num = Integer.parseInt(st.nextToken());
+				list.put(num, new int[] { i, j }); // 빙고판을 map으로 사용
+			}
+		}
+
+		int cnt = 0;
+
+		for (int i = 1; i <= 5; i++) {
+			st = new StringTokenizer(br.readLine());
+			for (int j = 1; j <= 5; j++) {
+				cnt++;
+				int num = Integer.parseInt(st.nextToken());
+				int[] temp = list.get(num);
+
+				int r = temp[0];
+				int c = temp[1];
+
+				x[r]++; // 가로열 체크
+				y[c]++; // 세로열 체크
+				if (r == c) diagonal[0]++; // 대각선 1
+				if (r + c == 6) diagonal[1]++; // 대각선 2
+
+				// 빙고 개수 체크
+				if (x[r] == 5 && !x_done[r]) {
+					bingo++;
+					x_done[r] = true;
+				}
+				if (y[c] == 5 && !y_done[c]) {
+					bingo++;
+					y_done[c] = true;
+				}
+				if (diagonal[0] == 5 && !d_done[0]) {
+					bingo++;
+					d_done[0] = true;
+				}
+				if (diagonal[1] == 5 && !d_done[1]) {
+					bingo++;
+					d_done[1] = true;
+				}
+
+				if (bingo >= 3) { // 조건 만족시
+					System.out.println(cnt);
+					return;
+				}
+			}
+		}
+	}
+}
+
diff --git a/week5/BOJ1205.java b/week5/BOJ1205.java
new file mode 100644
index 0000000..1558523
--- /dev/null
+++ b/week5/BOJ1205.java
@@ -0,0 +1,63 @@
+package week5;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.StringTokenizer;
+
+public class BOJ1205 {
+	
+	public static class rank { // 변수들을 저장하기 위한 클래스
+        int score;
+        int index;
+
+        public rank(int score, int index) {
+            this.score = score;
+            this.index = index;
+        }
+    }
+
+	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 taesoo = Integer.parseInt(st.nextToken());
+		int P = Integer.parseInt(st.nextToken());
+		StringBuilder sb = new StringBuilder();
+		if(N==0) { // 랭킹이 비어있는경우 무조건 1등이기 때문에 처리
+			sb.append("1");
+		}
+		else {
+			LinkedList<rank> list = new LinkedList<>(); // 랭크 타입의 리스트 생성
+			st = new StringTokenizer(br.readLine());
+			for(int i=0;i<N;i++) {
+				list.add(new rank(Integer.parseInt(st.nextToken()),i));
+			}
+			rank r = new rank(taesoo,N); // 태수는 항상 마지막에 넣음
+			list.add(r);
+			list.sort(new Comparator<rank>() { // 리스트를 스코어 기준 내림차순으로 정렬
+				@Override
+				public int compare(rank o1, rank o2) {
+					return o2.score-o1.score;
+				}
+			});
+			
+			if(list.indexOf(r)+1>P) { // 태수의 등수가 랭킹범위 밖인 경우
+				sb.append("-1");
+			}
+			else {
+				for(int i=0;i<=list.indexOf(r);i++) { // 태수의 등수가 랭킹범위 안인 경우
+					if(list.get(i).score==r.score) { // 태수와 동점이 있는지 찾아서
+						sb.append(list.indexOf(list.get(i))+1); // 태수는 동점인 경우 가장 후순위이기 때문에 가장 앞의 등수 출력
+                        break;
+					}
+				}
+			}
+		}
+		
+		System.out.println(sb);
+		
+		
+	}
+
+}
diff --git a/week5/BOJ1244.java b/week5/BOJ1244.java
new file mode 100644
index 0000000..a17a457
--- /dev/null
+++ b/week5/BOJ1244.java
@@ -0,0 +1,79 @@
+package week5;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ1244 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		int num = Integer.parseInt(st.nextToken())+1;
+		boolean[] onoff = new boolean[num]; // 스위치 온 오프를 boolean 타입 배열로 선언하여 관리
+
+		st = new StringTokenizer(br.readLine());
+		for (int i = 1; i < num; i++) {
+			int chk = Integer.parseInt(st.nextToken());
+			if (chk == 1)
+				onoff[i] = true;
+		}
+
+		int peoplenum = Integer.parseInt(br.readLine());
+
+		for (int i = 0; i < peoplenum; i++) {
+			st = new StringTokenizer(br.readLine());
+
+			int sex = Integer.parseInt(st.nextToken());
+			int idx = Integer.parseInt(st.nextToken());
+
+			if (sex == 1) { // 성별이 남자인 경우
+				int count = 1;
+				while (idx * count < num) { // 인덱스가 범위를 넘을 때 까지
+					onoff[idx * count] = !onoff[idx * count]; // 곱하면서 스위치를 조작
+					count++;
+				}
+			}
+
+			else { // 성별이 여자인 경우 지정한 인덱스의 스위치 기준 대칭인 곳의 스위치를 조작
+				int count = 1;
+				onoff[idx] = !onoff[idx]; // 지정 위치는 무조건 조작
+				while (true) {
+					if (idx - count >= 1 && idx + count < num) { // 인덱스 범위 판단
+						if (onoff[idx - count] == onoff[idx + count]) { // 대칭인지 판단하여 스위치 조작
+							onoff[idx - count] = !onoff[idx - count];
+							onoff[idx + count] = !onoff[idx + count];
+						} else { // 대칭이 아닌 경우 break
+							break;
+						}
+					} else {
+						break;
+					}
+					count++;
+				}
+
+			}
+		}
+
+		StringBuilder sb = new StringBuilder();
+		int count = 0;
+		for (int i = 1; i < num; i++) { // 출력 포맷에 맞게 수정
+			if(onoff[i]) {
+				sb.append("1 ");
+			}
+			else {
+				sb.append("0 ");
+			}
+			count++;
+			
+			if(count==20) {
+				sb.append("\n");
+				count=0;
+			}
+		}
+		
+		System.out.println(sb);
+
+	}
+
+}
diff --git a/week5/BOJ20125.java b/week5/BOJ20125.java
new file mode 100644
index 0000000..83626a0
--- /dev/null
+++ b/week5/BOJ20125.java
@@ -0,0 +1,71 @@
+package week5;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ20125 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		int num = Integer.parseInt(st.nextToken());
+
+		char[][] cookie = new char[num][num];
+		for (int i = 0; i < num; i++) {
+			cookie[i] = br.readLine().toCharArray(); // 입력의 각 칸에서 찾기 위해 한줄씩 받아서 char형 이중배열로 변환
+		}
+
+		int heartx = 0, hearty = 0;
+		boolean findheart = false;
+		for (int i = 0; i < num; i++) { // 배열을 0,0에서 찾아가며 쿠키가 처음 올라가 있는 곳을 찾음 -> 그곳이 쿠키의 머리이고 한칸 아래가 심장
+			for (int j = 0; j < num; j++) {
+				if (cookie[i][j] == '*') {
+					findheart = true;
+					heartx = j;
+					hearty = i + 1;
+				}
+			}
+			if (findheart) {
+				break;
+			}
+		}
+		int larm = 0, rarm = 0, lleg = 0, rleg = 0, back = 0;
+		
+		for(int i=0;i<heartx;i++) { // 심장과 같은 행이면서 심장의 왼쪽
+			if(cookie[hearty][i]=='*') {
+				larm++;
+			}
+		}
+		
+		for(int i=heartx+1;i<num;i++) { // 심장과 같은 행이면서 심장의 오른쪽
+			if(cookie[hearty][i]=='*') {
+				rarm++;
+			}
+		}
+		
+		for(int i=hearty+1;i<num;i++) { // 심장과 같은 열이면서 심장의 아래쪽
+			if(cookie[i][heartx]=='*') {
+				back++;
+			}
+		}
+		
+		for(int i=hearty+1;i<num;i++) { // 심장의 남서쪽 칸들
+			for(int j=0;j<heartx;j++) {
+				if(cookie[i][j]=='*') {
+					lleg++;
+				}
+			}
+		}
+		
+		for(int i=hearty+1;i<num;i++) { // 심장의 동남쪽 칸들
+			for(int j=heartx+1;j<num;j++) {
+				if(cookie[i][j]=='*') {
+					rleg++;
+				}
+			}
+		}
+		
+		System.out.println((hearty+1) +" "+(heartx+1)+"\n"+larm+" "+rarm+" "+back+" "+lleg+" "+rleg);
+	}
+
+}
diff --git a/week5/BOJ25757.java b/week5/BOJ25757.java
new file mode 100644
index 0000000..f1313d9
--- /dev/null
+++ b/week5/BOJ25757.java
@@ -0,0 +1,35 @@
+package week5;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+
+public class BOJ25757 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		int num = Integer.parseInt(st.nextToken());
+		String game = st.nextToken();
+		HashMap<String, Integer> hash = new HashMap<>(); // 한 번 게임한 플레이어와는 다시 하지 않기 때문에 해시맵 사용
+
+		for (int i = 0; i < num; i++) {
+			hash.put(br.readLine(), null);
+		}
+
+		int length = hash.size();
+
+		switch (game) { // 게임에 필요한 인원은 2,3,4 이지만 임스가 참여하기 때문에 1,2,3으로 나눔
+		case "Y":
+			System.out.println(length / 1);
+			break;
+		case "F":
+			System.out.println(length / 2);
+			break;
+		case "O":
+			System.out.println(length / 3);
+			break;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/week5/BOJ4659.java b/week5/BOJ4659.java
new file mode 100644
index 0000000..24ddb5e
--- /dev/null
+++ b/week5/BOJ4659.java
@@ -0,0 +1,67 @@
+package week5;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class BOJ4659 {
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringBuilder sb = new StringBuilder();
+		while(true) {
+			String str = br.readLine();
+			boolean hasmo = false; // 규칙 1 : 모음이 하나 이상 반드시 있어야 함을 체크하기 위한 변수
+			char[] moem = {'a','e','i','u','o'}; // 모음을 체크하기 위해 미리 선언
+			int seqcount=0; // 규칙 2 : 3연속의 모음, 자음을 체크하기 위한 변수
+			boolean sameduple = false; // 규칙 3 : 같은 문자가 연속을 체크하기 위한 변수
+			if(str.equals("end")) {
+				break;
+			}
+			
+			sb.append("<"+str+"> "); // 출력 포맷에 맡게 만듬
+			
+			char[] strchar = str.toCharArray(); // 한글자씩 확인하기위해 배열로 변환
+			
+			for(int i=0;i<str.length();i++) {
+				boolean ismo = false; // 각 글자가 모음인지 확인하기 위한 변수
+				for(int j=0;j<5;j++) {
+					if(strchar[i]==moem[j]) { // 모음 이면
+						hasmo = true;
+						ismo = true;
+						if(seqcount<0) { // 모음 일때는 seqcount가 양수로 올라감
+							seqcount=0;
+						}
+						seqcount++;
+					}
+				}
+				if(!ismo) { // 자음 이면
+					if(seqcount>0) { // 자음 일때는 seqcount가 음수로 내려감
+						seqcount=0;
+					}
+					seqcount--;
+				}
+				
+				if(i+1<str.length()) { // 같은 문자가 연속으로 오는지 판단
+					if(strchar[i]!='e'&&strchar[i]!='o') {
+						if(strchar[i]==strchar[i+1]) {
+							sameduple = true;
+						}
+					}
+				}
+				
+				if(Math.abs(seqcount)>2||sameduple) { // 한 글자의 검증이 끝났을 때 이미 규칙에 어긋나면 탈출
+					break;
+				}
+			}
+			
+			if(Math.abs(seqcount)<3&&!sameduple&&hasmo) { // 모든 규칙에 부합하면
+				sb.append("is acceptable.\n");
+			}
+			else {
+				sb.append("is not acceptable.\n"); // 규칙에 어긋나면
+			}
+			
+		}
+		System.out.println(sb);
+	}
+
+}
\ No newline at end of file
diff --git a/week6/BOJ1094.java b/week6/BOJ1094.java
new file mode 100644
index 0000000..910b45d
--- /dev/null
+++ b/week6/BOJ1094.java
@@ -0,0 +1,19 @@
+package week6;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class BOJ1094 {
+    public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int X = Integer.parseInt(br.readLine());
+		int count = 0;
+		for (int i = 0; i <= 6; i++) { // 최대 64까지 비트연산
+			if ((X & 1 << i) != 0)
+				count++;
+		}
+
+		System.out.println(count);
+	}
+}
diff --git a/week6/BOJ11053.java b/week6/BOJ11053.java
new file mode 100644
index 0000000..7739c95
--- /dev/null
+++ b/week6/BOJ11053.java
@@ -0,0 +1,40 @@
+package week6;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ11053 {
+     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[] arr = new int[N];
+        int[] dp = new int[N];
+        st = new StringTokenizer(br.readLine());
+
+        for (int i = 0; i < N; i++) {
+            arr[i] = Integer.parseInt(st.nextToken());
+        }
+
+        for (int i = 0; i < N; i++) {
+            dp[i] = 1;  // 각 자리부터 증가하는 부분수열은 최소 1부터 시작
+        }
+
+        for (int i = 1; i < N; i++) { // 현재 자리
+            for (int j = 0; j < i; j++) { // 0인덱스 부터 현재 직전 까지
+                if (arr[i] > arr[j]) { // 작은 것이 있으면
+                    dp[i] = Math.max(dp[i], dp[j] + 1); // 증가하는 부분수열의 길이 증가
+                }
+            }
+        }
+
+        int max = 0;
+        for (int i = 0; i < N; i++) {
+            max = Math.max(max, dp[i]); // 최대치 뽑음
+        }
+
+        System.out.println(max);
+    }
+}
diff --git a/week6/BOJ15651.java b/week6/BOJ15651.java
new file mode 100644
index 0000000..9b6071b
--- /dev/null
+++ b/week6/BOJ15651.java
@@ -0,0 +1,40 @@
+package week6;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ15651 {
+    static int N,M;
+	static int[] numbers;
+	static StringBuilder sb = new StringBuilder();
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		
+		N =Integer.parseInt(st.nextToken());
+		M = Integer.parseInt(st.nextToken());
+		
+		numbers = new int[M];
+		
+		permutation(0);
+		
+		System.out.println(sb);
+	}
+	
+	public static void permutation(int cnt) {
+		if (cnt == M) {
+			for(int a : numbers) {
+				sb.append(a+" ");
+			}
+			sb.append("\n");
+			return;
+		}
+
+		for (int i = 1; i <= N; i++) { // 중복 조합이므로 start 설정 필요 X
+			numbers[cnt] = i;
+			permutation(cnt + 1);
+		}
+	}
+}
diff --git a/week6/BOJ6603.java b/week6/BOJ6603.java
new file mode 100644
index 0000000..06ea37c
--- /dev/null
+++ b/week6/BOJ6603.java
@@ -0,0 +1,49 @@
+package week6;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ6603 {
+    static int[] arr,numbers;
+	static int k;
+	static StringBuilder sb = new StringBuilder();
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		while(true) {
+			StringTokenizer st = new StringTokenizer(br.readLine());
+			k = Integer.parseInt(st.nextToken());
+			
+			if(k==0) { // 0 입력으로 반복 종료
+				break;
+			}
+			
+			arr = new int[k];
+			numbers = new int[6];
+			for(int i=0;i<k;i++) {
+				arr[i]=Integer.parseInt(st.nextToken());
+			}
+			combination(0,0);
+			sb.append("\n");
+		}
+		
+		System.out.println(sb);
+	}
+	
+	public static void combination(int cnt, int idx) {
+		if(cnt==6) { // 6개 뽑기
+			for(int a:numbers) {
+				sb.append(a+" ");
+			}
+			sb.append("\n");
+			return;
+		}
+		
+		for (int i = idx; i < k; i++) {
+			numbers[cnt] = arr[i]; // k개의 후보 숫자들을 순회하면서 조합 구성
+			combination(cnt + 1, i + 1);
+		}
+	}
+}
diff --git a/week7/BOJ15652.java b/week7/BOJ15652.java
new file mode 100644
index 0000000..3da24de
--- /dev/null
+++ b/week7/BOJ15652.java
@@ -0,0 +1,37 @@
+package week7;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ15652 {
+
+	static int N,M;
+	static int[] numbers;
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken());
+		M = Integer.parseInt(st.nextToken()); // M개를 고른 수열
+		numbers = new int[M];
+		
+		permutation(0,1); // start를 1로 하여 1 ~ N 까지의 수 중 순열
+	}
+
+	
+	public static void permutation(int cnt, int start) {
+		if(cnt==M) {
+			for(int a:numbers) {
+				System.out.print(a+" ");
+			}
+			System.out.println();
+			return;
+		}
+		
+		for(int i=start;i<=N;i++) {
+			numbers[cnt]=i;
+			permutation(cnt+1,i); // 중복을 허용하기 때문에 start 파라미터는 유지
+		}
+	}
+}
\ No newline at end of file
diff --git a/week7/BOJ15654.java b/week7/BOJ15654.java
new file mode 100644
index 0000000..eda3ebe
--- /dev/null
+++ b/week7/BOJ15654.java
@@ -0,0 +1,53 @@
+package week7;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ15654 {
+
+	static int N,M;
+	static int[] numbers, res;
+	static boolean[] isSelected;
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken()); // N개의 숫자
+		M = Integer.parseInt(st.nextToken()); // M개를 뽑은 수열
+		numbers = new int[N];
+		res = new int[M];
+		isSelected = new boolean[N];
+		
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<N;i++) {
+			numbers[i] = Integer.parseInt(st.nextToken());
+		}
+		
+		Arrays.sort(numbers); // 오름차순을 위한 정렬
+		
+		permutation(0);
+	}
+
+	
+	public static void permutation(int cnt) {
+		if(cnt==M) {
+			for(int a:res) {
+				System.out.print(a+" ");
+			}
+			System.out.println();
+			return;
+		}
+		
+		for(int i=0;i<N;i++) { // 항상 0부터 시작하여 순열뽑음
+			if(isSelected[i])
+				continue;
+			
+			isSelected[i] = true; // 중복을 막기 위한 선택 처리
+			res[cnt] = numbers[i];
+			permutation(cnt + 1);
+			isSelected[i] = false; // 원상복구
+		}
+	}
+}
\ No newline at end of file
diff --git a/week7/BOJ15655.java b/week7/BOJ15655.java
new file mode 100644
index 0000000..fba4820
--- /dev/null
+++ b/week7/BOJ15655.java
@@ -0,0 +1,53 @@
+package week7;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ15655 {
+
+	static int N,M;
+	static int[] numbers, res;
+	static boolean[] isSelected;
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken());
+		M = Integer.parseInt(st.nextToken());
+		numbers = new int[N]; // N개의 수
+		res = new int[M]; // M개를 뽑은 조합
+		isSelected = new boolean[N];
+		
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<N;i++) {
+			numbers[i] = Integer.parseInt(st.nextToken());
+		}
+		
+		Arrays.sort(numbers);
+		
+		combination(0,0);
+	}
+
+	
+	public static void combination(int cnt, int start) {
+		if(cnt==M) {
+			for(int a:res) {
+				System.out.print(a+" ");
+			}
+			System.out.println();
+			return;
+		}
+		
+		for(int i=start;i<N;i++) { // 탐색 인덱스를 start 부터 하여 조합 구함
+			if(isSelected[i])
+				continue;
+			
+			isSelected[i] = true;
+			res[cnt] = numbers[i];
+			combination(cnt + 1, i+1); // start 를 1 증가 시켜 중복을 막음
+			isSelected[i] = false;
+		}
+	}
+}
\ No newline at end of file
diff --git a/week7/BOJ16938.java b/week7/BOJ16938.java
new file mode 100644
index 0000000..7cf4805
--- /dev/null
+++ b/week7/BOJ16938.java
@@ -0,0 +1,68 @@
+package week7;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ16938 {
+
+	static int N, L, R, X, M, res, sum, max, min;
+	static int[] numbers;
+	static boolean[] isSelected;
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken()); // 총 문제 개수
+		L = Integer.parseInt(st.nextToken()); // 문제 난이도의 합 최소 범위
+		R = Integer.parseInt(st.nextToken()); // 문제 난이도의 합 최대 범위
+		X = Integer.parseInt(st.nextToken()); // 최고난이도 문제와 최저난이도 문제의 차의 최소범위
+		numbers = new int[N]; // N개의 문제 난이도 배열
+		isSelected = new boolean[N]; // 선택처리를 위한 배열
+		res = 0;
+		
+		st = new StringTokenizer(br.readLine());
+		for (int i = 0; i < N; i++) {
+			numbers[i] = Integer.parseInt(st.nextToken());
+		}
+
+		Arrays.sort(numbers);
+
+		subset(0,0);
+		
+		System.out.println(res);
+	}
+
+	public static void subset(int cnt, int pick) {
+		if (cnt == N) {
+			sum = 0;
+			max = Integer.MIN_VALUE; // 고른 문제 중 최고난이도
+			min = Integer.MAX_VALUE; // 고른 문제 중 최저난이도
+			if (pick >= 2) { // 최소 2개 이상 고른 경우에 조건 판단
+				for (int i = 0; i < N; i++) {
+					if (isSelected[i]) {
+						sum += numbers[i]; // 난이도 합 계산
+						if (max < numbers[i]) // 최대값 갱신
+							max = numbers[i];
+						if (min > numbers[i]) // 최소값 갱신
+							min = numbers[i];
+					}
+				}
+
+				if (sum >= L && sum <= R && (max - min) >= X) // 조건 확인
+					res++;
+			}
+
+			return;
+		}
+
+		isSelected[cnt] = true; // 고른 경우
+		subset(cnt + 1, pick + 1);
+
+		isSelected[cnt] = false; // 안고른 경우
+		subset(cnt + 1, pick);
+
+	}
+
+}
diff --git a/week7/BOJ1759.java b/week7/BOJ1759.java
new file mode 100644
index 0000000..77c5a01
--- /dev/null
+++ b/week7/BOJ1759.java
@@ -0,0 +1,66 @@
+package week7;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ1759 {
+
+	static int L,C;
+	static char[] characters, res;
+	static boolean[] isSelected;
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		L = Integer.parseInt(st.nextToken()); // L개를 뽑아 비밀번호 생성
+		C = Integer.parseInt(st.nextToken()); // 총 C개의 문자가 존재
+		characters = new char[C]; // 문자 배열
+		res = new char[L]; // 비밀번호 배열
+		isSelected = new boolean[C]; // 선택 처리를 위한 배열
+		
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<C;i++) {
+			characters[i] = st.nextToken().charAt(0);
+		}
+		
+		Arrays.sort(characters); // 알파벳 오름차순을 위한 정렬
+		
+		permutation(0,0);
+	}
+
+	
+	public static void permutation(int cnt, int start) {
+		if(cnt==L) {
+			boolean ismoem=false;
+			int jaem=0;
+			for(char a:res) { // 자음과 모음 조건을 파악
+				if(a=='a'||a=='e'||a=='i'||a=='o'||a=='u') {
+					ismoem=true; // 최소 1개의 모음이 있으면 true
+				}
+				else {
+					jaem++; // 자음은 최소 2개이상이 필요하므로 개수 체크
+				}
+			}
+			if(ismoem&&jaem>=2) { // 1개 이상의 모음, 2개 이상의 자음인 경우 출력
+				for(char a:res) {
+					System.out.print(a);
+				}
+				System.out.println();
+			}
+			
+			return;
+		}
+		
+		for(int i=start;i<C;i++) { // 중복방지를 위해 start부터 탐색
+			if(isSelected[i])
+				continue;
+			
+			isSelected[i] = true; // 선택 처리
+			res[cnt] = characters[i];
+			permutation(cnt + 1, i+1);
+			isSelected[i] = false; // 원상복구
+		}
+	}
+}
diff --git a/week8/BOJ11660.java b/week8/BOJ11660.java
new file mode 100644
index 0000000..dc00522
--- /dev/null
+++ b/week8/BOJ11660.java
@@ -0,0 +1,39 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ11660 {
+    
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        
+        int N = Integer.parseInt(st.nextToken());
+        int M = Integer.parseInt(st.nextToken());
+        
+        int[][] grid = new int[N+1][N+1];
+        
+        for(int i=1;i<=N;i++) {
+        	st = new StringTokenizer(br.readLine());
+        	for(int j=1;j<=N;j++) {
+        		int tmp = Integer.parseInt(st.nextToken());
+        		grid[i][j] = tmp + grid[i-1][j] + grid[i][j-1] - grid[i-1][j-1]; // DP를 사용하여 값 저장
+        	}
+        }
+
+        for(int i=0;i<M;i++) {
+        	st = new StringTokenizer(br.readLine());
+        	int x1 = Integer.parseInt(st.nextToken());
+        	int y1 = Integer.parseInt(st.nextToken());
+        	int x2 = Integer.parseInt(st.nextToken());
+        	int y2 = Integer.parseInt(st.nextToken());
+        	
+        	int res = grid[x2][y2] - grid[x1-1][y2] - grid[x2][y1-1] + grid[x1-1][y1-1]; // 규칙에 따른 값 구하기
+        	sb.append(res).append("\n");
+        }
+        
+        System.out.println(sb);
+    }
+    
+}
diff --git a/week8/BOJ11725.java b/week8/BOJ11725.java
new file mode 100644
index 0000000..f776f2c
--- /dev/null
+++ b/week8/BOJ11725.java
@@ -0,0 +1,57 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ11725 {
+    
+    static int N;
+    static List<Integer>[] graph;
+    static int[] res;
+    static boolean[] isSelected;
+    
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        N = Integer.parseInt(st.nextToken()); // N개의 숫자
+        
+        graph = new ArrayList[N+1];  // 인접 리스트로 변경
+        for (int i = 1; i <= N; i++) {
+            graph[i] = new ArrayList<>();
+        }
+        
+        isSelected = new boolean[N+1];
+        res = new int[N+1];
+        
+        for (int i = 0; i < N-1; i++) {
+            st = new StringTokenizer(br.readLine());
+            int n1 = Integer.parseInt(st.nextToken());
+            int n2 = Integer.parseInt(st.nextToken());
+            graph[n1].add(n2);
+            graph[n2].add(n1);
+        }
+        
+        bfs(1);// 트리의 루트가 1이라고 가정
+        
+        for (int i = 2; i <= N; i++) {
+            System.out.println(res[i]);
+        }
+    }
+    
+    static void bfs(int start) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(start);
+        isSelected[start] = true;
+        
+        while (!queue.isEmpty()) {
+            int current = queue.poll();
+            
+            for (int neighbor : graph[current]) {
+                if (!isSelected[neighbor]) {// 각 노드의 부모를 찾기 때문에 현재 노드로 부모 저장
+                    isSelected[neighbor] = true;
+                    res[neighbor] = current;
+                    queue.add(neighbor);
+                }
+            }
+        }
+    }
+}
diff --git a/week8/BOJ15663.java b/week8/BOJ15663.java
new file mode 100644
index 0000000..677e489
--- /dev/null
+++ b/week8/BOJ15663.java
@@ -0,0 +1,63 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+public class BOJ15663 {
+	
+	static int N,M;
+	static int[] numbers, res;
+	static boolean[] isSelected;
+	static Set<String> set = new HashSet<>();
+	
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		N = Integer.parseInt(st.nextToken()); // N개의 숫자
+		M = Integer.parseInt(st.nextToken()); // M개를 뽑은 수열
+		numbers = new int[N];
+		res = new int[M];
+		isSelected = new boolean[N];
+		
+		st = new StringTokenizer(br.readLine());
+		for(int i=0;i<N;i++) {
+			numbers[i] = Integer.parseInt(st.nextToken());
+		}
+		
+		Arrays.sort(numbers); // 오름차순을 위한 정렬
+		
+		permutation(0);
+	}
+
+	
+	public static void permutation(int cnt) {
+		if(cnt==M) {
+			StringBuilder sb = new StringBuilder();
+			for(int i=0;i<M;i++) {
+				sb.append(res[i]+" ");
+			}
+			
+			String seq = sb.toString().trim();
+			
+			if(!set.contains(seq)) {
+				set.add(seq);
+				System.out.println(seq);
+			}
+			
+			return;
+		}
+		
+		for(int i=0;i<N;i++) { // 항상 0부터 시작하여 순열뽑음
+			if(isSelected[i])
+				continue;
+			
+			isSelected[i] = true; // 중복을 막기 위한 선택 처리
+			res[cnt] = numbers[i];
+			permutation(cnt + 1);
+			isSelected[i] = false; // 원상복구
+		}
+	}
+
+}
diff --git a/week8/BOJ1753.java b/week8/BOJ1753.java
new file mode 100644
index 0000000..fa019ba
--- /dev/null
+++ b/week8/BOJ1753.java
@@ -0,0 +1,93 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+class Node implements Comparable<Node> {
+	int index;
+	int weight;
+
+	public Node(int index, int cost) {
+		this.index = index;
+		this.weight = cost;
+	}
+
+	@Override
+	public int compareTo(Node o) {
+		return Integer.compare(this.weight, o.weight);
+	}
+}
+
+public class BOJ1753 {
+	
+	static ArrayList<Node>[] graph;
+	static int N,M;
+
+	public static void main(String[] args) throws Exception {
+
+		// 그래프 입력 받기
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		// 정점의 개수, 간선의 개수
+		N = Integer.parseInt(st.nextToken());
+		M = Integer.parseInt(st.nextToken());
+		int start = Integer.parseInt(br.readLine());
+
+		graph = new ArrayList[N + 1]; // 인접 리스트 사용
+		for (int i = 0; i <= N; i++)
+			graph[i] = new ArrayList<>();
+
+		for (int i = 0; i < M; i++) {
+			st = new StringTokenizer(br.readLine());
+			int u = Integer.parseInt(st.nextToken());
+			int v = Integer.parseInt(st.nextToken());
+			int w = Integer.parseInt(st.nextToken());
+
+			graph[u].add(new Node(v, w));
+		}
+
+		// 다익스트라 알고리즘 수행
+		Dijkstra(N, start);
+
+	}
+
+	// 노드의 크기, 출발지
+	public static void Dijkstra(int n, int start) { //다익스트라
+		boolean[] check = new boolean[n + 1];
+		int[] dist = new int[n + 1];
+		int INF = Integer.MAX_VALUE;
+
+		Arrays.fill(dist, INF);
+		dist[start] = 0;
+
+		PriorityQueue<Node> pq = new PriorityQueue<>(); // priorityqueue를 사용한 다익스트라
+		pq.offer(new Node(start, 0));
+
+		while (!pq.isEmpty()) {
+			int curr = pq.poll().index;
+
+			if (check[curr]) // 이미 방문했다면 패스
+				continue;
+			check[curr] = true;
+
+			// index의 연결된 정점 비교
+			for (Node next : graph[curr]) {
+				if (dist[next.index] > dist[curr] + next.weight) { // 기존에 가는 비용이 새로 파악한 루트보다 큰 경우 최신화
+					dist[next.index] = dist[curr] + next.weight;
+
+					pq.offer(new Node(next.index, dist[next.index]));
+				}
+			}
+		}
+
+		// 최소거리 출력
+		for (int i=1;i<=N;i++) {
+			if (dist[i] == INF)
+				System.out.println("INF");
+			else
+				System.out.println(dist[i]);
+		}
+	}
+}
\ No newline at end of file
diff --git a/week8/BOJ5639.java b/week8/BOJ5639.java
new file mode 100644
index 0000000..8990943
--- /dev/null
+++ b/week8/BOJ5639.java
@@ -0,0 +1,61 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class BOJ5639 {
+	static class Node {
+		int num;
+		Node lchild;
+		Node rchild;
+
+		public Node(int num) {
+			this.num = num;
+			lchild = rchild = null;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringBuilder sb = new StringBuilder();
+
+		Node root = new Node(Integer.parseInt(br.readLine()));
+
+		Stack<Node> stack = new Stack<>();
+
+		while (true) {
+			String s = br.readLine();
+			if (s == null || s.equals("")) // 입력 종료 처리
+				break;
+
+			if (stack.isEmpty()) {
+				stack.push(root);
+			}
+
+			Node tmp = new Node(Integer.parseInt(s));
+
+			if (stack.peek().num > tmp.num) { // 다음 출력되는 수가 현재 수보다 작다면
+				stack.peek().lchild = tmp; // 왼쪽자식으로 저장
+				stack.push(tmp);
+			} else { // 크다면
+				Node parent = null;
+				while (!stack.isEmpty() && stack.peek().num < tmp.num) { // 그 노드의 적절한 위치 탐색
+					parent = stack.pop();
+				}
+				parent.rchild = tmp; // 오른쪽 자식으로 저장
+				stack.push(tmp);
+			}
+		}
+
+		print(root);
+	}
+
+	public static void print(Node n) { // 후위순회
+		if (n == null) {
+			return;
+		}
+		print(n.lchild);
+		print(n.rchild);
+		System.out.println(n.num);
+	}
+
+}
diff --git a/week9/BOJ10026.java b/week9/BOJ10026.java
new file mode 100644
index 0000000..67f766f
--- /dev/null
+++ b/week9/BOJ10026.java
@@ -0,0 +1,115 @@
+package week9;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public class BOJ10026 {
+
+	static int[][] arr;
+	static int[][] arr2;
+	static int n, m, s;
+	static boolean[][] visited;
+	static int[][] dir = { { 0, -1 }, { 0, 1 }, { 1, 0 }, { -1, 0 } };
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		n = Integer.parseInt(br.readLine());
+		arr = new int[n][n]; // 일반 사람용 행렬
+		arr2 = new int[n][n]; // 적록색맹 저장용 행렬
+		visited = new boolean[n][n];
+
+		for (int i = 0; i < n; i++) { // 편의를 위해 각 문자를 숫자로 변환하여 입력
+			String str = br.readLine();
+			for (int j = 0; j < n; j++) {
+				char c = str.charAt(j);
+				if (c == 'R') {
+					arr[i][j] = 1;
+					arr2[i][j]=1;
+				} else if (c == 'G') { // 적록색맹은 R과 G일때 모두 1
+					arr[i][j] = 2;
+					arr2[i][j]=1;
+				} else if (c == 'B') {
+					arr[i][j] = 3;
+					arr2[i][j]=3;
+				}
+			}
+		}
+
+		int count=0; // 일반사람용
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < n; j++) { // 방문안한 구역마다 체크하며 횟수 증가
+				if(!visited[i][j]&&arr[i][j]==1) {
+					count++;
+					bfs(new int[] {i,j},1);
+				}
+				else if(!visited[i][j]&&arr[i][j]==2) {
+					count++;
+					bfs(new int[] {i,j},2);
+				}
+				else if(!visited[i][j]&&arr[i][j]==3) {
+					count++;
+					bfs(new int[] {i,j},3);
+				}
+			}
+		}
+		
+		int count2=0; // 적록색맹용
+		visited = new boolean[n][n]; // 방문배열 초기화
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < n; j++) { // 방문안한 새 구역마다 체크하며 횟수 증가
+				if(!visited[i][j]&&arr2[i][j]==1) {
+					count2++;
+					bfs2(new int[] {i,j},1);
+				}
+				else if(!visited[i][j]&&arr2[i][j]==3) {
+					count2++;
+					bfs2(new int[] {i,j},3);
+				}
+			}
+		}
+		
+		System.out.println(count+" "+count2);
+
+	}
+
+	static void bfs(int[] start, int col) { // 일반인용 bfs 함수
+		Queue<int[]> list = new ArrayDeque<>();
+		list.add(start);
+		visited[start[0]][start[1]] = true;
+
+		while (list.size() != 0) {
+			int[] idx = list.poll();
+			for (int i = 0; i < 4; i++) {
+				int dy = idx[0] + dir[i][0];
+				int dx = idx[1] + dir[i][1];
+				if (dx >= 0 && dx < n && dy >= 0 && dy < n && !visited[dy][dx] && arr[dy][dx] == col) {
+					visited[dy][dx] = true;
+					list.add(new int[] { dy, dx });
+				}
+			}
+
+		}
+	}
+	static void bfs2(int[] start, int col) { // 적록색맹용 bfs 함수
+		Queue<int[]> list = new ArrayDeque<>();
+		list.add(start);
+		visited[start[0]][start[1]] = true;
+
+		while (list.size() != 0) {
+			int[] idx = list.poll();
+			for (int i = 0; i < 4; i++) {
+				int dy = idx[0] + dir[i][0];
+				int dx = idx[1] + dir[i][1];
+				if (dx >= 0 && dx < n && dy >= 0 && dy < n && !visited[dy][dx] && arr2[dy][dx] == col) {
+					visited[dy][dx] = true;
+					list.add(new int[] { dy, dx });
+				}
+			}
+
+		}
+	}
+}
+
diff --git a/week9/BOJ1012.java b/week9/BOJ1012.java
new file mode 100644
index 0000000..b61612e
--- /dev/null
+++ b/week9/BOJ1012.java
@@ -0,0 +1,78 @@
+package week9;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ1012 {
+
+	static int N, M, K, ans, max;
+	static int[][] map;
+	static boolean[][] chk;
+	static boolean temp;
+	static int[][] dir = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int T = Integer.parseInt(br.readLine());
+
+		for (int t = 0; t < T; t++) {
+			StringTokenizer st = new StringTokenizer(br.readLine());
+			M = Integer.parseInt(st.nextToken()); // 밭 가로 길이
+			N = Integer.parseInt(st.nextToken()); // 밭 세로 길이
+			K = Integer.parseInt(st.nextToken()); // 배추가 심어진 위치
+
+			map = new int[N][M];
+
+			for (int i = 0; i < K; i++) { // 배추 위치 입력받아 저장
+				st = new StringTokenizer(br.readLine());
+				int x = Integer.parseInt(st.nextToken());
+				int y = Integer.parseInt(st.nextToken());
+
+				map[y][x] = 1;
+			}
+			max = 0;
+
+			chk = new boolean[N][M];
+			ans = 0;
+			for (int i = 0; i < N; i++) {
+				for (int j = 0; j < M; j++) {
+					temp = false; // 배추밭인지 아닌지 판단단
+					find(i, j);
+					if (temp) { // 붙어있는 배추밭에서는 배추벌레 1마리만 필요
+						ans++;
+					}
+				}
+			}
+			if (max < ans) {
+				max = ans;
+			}
+
+			System.out.println(max);
+		}
+	}
+
+	public static void find(int y, int x) {
+		if (chk[y][x] || map[y][x] != 1) { // 이미 체크 했거나 배추가 아니면
+			return;
+		} else {
+			for (int i = 0; i < 4; i++) { // 상하좌우 탐색
+				int dy = y + dir[i][0];
+				int dx = x + dir[i][1];
+
+				if (dy < 0 || dy >= N || dx < 0 || dx >= M) {
+					continue;
+				} else {
+					chk[y][x] = true;
+					temp = true;
+					find(dy, dx);
+				}
+			}
+		}
+		return;
+	}
+
+}
+
diff --git a/week9/BOJ11404.java b/week9/BOJ11404.java
new file mode 100644
index 0000000..9611223
--- /dev/null
+++ b/week9/BOJ11404.java
@@ -0,0 +1,58 @@
+package week9;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ11404 {
+
+	static int[][] arr;
+	static int n, m;
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st;
+		n = Integer.parseInt(br.readLine());
+		m = Integer.parseInt(br.readLine());
+		arr = new int[n + 1][n + 1];
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				if (i == j)
+					arr[i][j] = 0; // 자기 자신으로 갈 수는 없으니 0
+				else
+					arr[i][j] = 9900001;// 갈 수 없는 경우 최대 비용 +1 로 설정
+			}
+		}
+
+		for (int i = 0; i < m; i++) { // 입력받아서 저장
+			st = new StringTokenizer(br.readLine());
+			int from = Integer.parseInt(st.nextToken());
+			int to = Integer.parseInt(st.nextToken());
+			int cost = Integer.parseInt(st.nextToken());
+			arr[from][to] = Math.min(arr[from][to], cost);
+		}
+
+		for (int k = 1; k <= n; k++) { // 플로이드 워셜 알고리즘 사용하여 비용 계산
+			for (int i = 1; i <= n; i++) {
+				for (int j = 1; j <= n; j++) {
+					arr[i][j] = Math.min(arr[i][j], arr[i][k] + arr[k][j]);
+				}
+			}
+		}
+
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				if (arr[i][j] > 9900000 || arr[i][j] == 0) { // 0이거나 최대비용보다 비싸면 0으로 출력
+					System.out.print("0 ");
+				} else { // 갈 수 있는 경우 비용 출력
+					System.out.print(arr[i][j] + " ");
+				}
+			}
+			System.out.println();
+		}
+
+	}
+
+}
+
diff --git a/week9/BOJ1260.java b/week9/BOJ1260.java
new file mode 100644
index 0000000..c97e099
--- /dev/null
+++ b/week9/BOJ1260.java
@@ -0,0 +1,74 @@
+package week9;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ1260 {
+
+	static int[][] arr;
+	static int n, m, s;
+	static boolean[] visited;
+
+	public static void main(String[] args) throws Exception {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		n = Integer.parseInt(st.nextToken());
+		m = Integer.parseInt(st.nextToken());
+		s = Integer.parseInt(st.nextToken());
+		arr = new int[n + 1][n + 1]; // 인접행렬 사용 (N이 1000개이기 때문에 무방)
+		visited = new boolean[n + 1];
+
+		for (int i = 0; i < m; i++) { // 무향 그래프로 입력받기
+			st = new StringTokenizer(br.readLine());
+			int to = Integer.parseInt(st.nextToken());
+			int from = Integer.parseInt(st.nextToken());
+
+			arr[to][from] = 1;
+			arr[from][to] = 1;
+		}
+
+		dfs(s);
+		System.out.println();
+		visited = new boolean[n + 1];
+		bfs(s);
+	}
+
+	static void dfs(int start) { // dfs
+
+		visited[start] = true;
+		System.out.print(start + " ");
+
+		for (int i = 1; i <= n; i++) {
+			if (arr[start][i] == 1 && !visited[i]) {
+				dfs(i);
+			}
+		}
+
+	}
+
+	static void bfs(int start) { // bfs
+
+		Queue<Integer> list = new ArrayDeque<>();
+		list.add(start);
+		visited[start] = true;
+
+		while (list.size() != 0) {
+			int idx = list.poll();
+			System.out.print(idx + " ");
+			for (int i = 1; i <= n; i++) {
+				if (arr[idx][i] == 1 && !visited[i]) {
+					visited[i] = true;
+					list.add(i);
+				}
+			}
+		}
+
+	}
+
+}
+
diff --git a/week9/BOJ1697.java b/week9/BOJ1697.java
new file mode 100644
index 0000000..0aae360
--- /dev/null
+++ b/week9/BOJ1697.java
@@ -0,0 +1,62 @@
+package week9;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class BOJ1697 {
+
+	static int[] line;
+	static boolean[] visited;
+	static int N, K, count;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		N = Integer.parseInt(st.nextToken());
+		K = Integer.parseInt(st.nextToken());
+
+		visited = new boolean[100001];
+		line = new int[100001];
+		bfs(N);
+		
+		System.out.println(line[K]);
+	}
+
+	public static void bfs(int start) {
+		Queue<Integer> list = new ArrayDeque<>();
+		visited[start] = true;
+		list.offer(start);
+
+		while (!list.isEmpty()) {
+			int n = list.size(); // 같은 시간에 확인해야 하는 위치 수수
+			for(int k=0;k<n;k++) {
+				int cur = list.poll();
+				line[cur]=count;
+				if (cur == K)
+					return;
+				for (int i = 0; i < 3; i++) {
+					int dx = cur;
+					if (i == 0) { // 한 칸 앞으로
+						dx += 1;
+					} else if (i == 1) { // 한 칸 뒤로
+						dx -= 1;
+					} else { // 현재 좌표에서 2배로로
+						dx *= 2;
+					}
+					if(dx>=0&&dx<100001&&!visited[dx]) { // 조건에 맞으면 큐에 추가가
+						list.offer(dx);
+						visited[dx]=true;
+					}
+				}
+			}
+			count++; // 1초 추가
+		}
+	}
+
+}
+