diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000..13566b8
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/algo.iml b/.idea/algo.iml
new file mode 100644
index 0000000..d6ebd48
--- /dev/null
+++ b/.idea/algo.iml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000..1b2d693
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..a1e279a
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000..ada7f84
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Algorithm-study-3 b/Algorithm-study-3
new file mode 160000
index 0000000..a495cb5
--- /dev/null
+++ b/Algorithm-study-3
@@ -0,0 +1 @@
+Subproject commit a495cb51a7510ccb8c8dda4b286dcb9279705bf1
diff --git a/README.md b/README.md
index 745bf91..b7d77bf 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
- 공통 문제 마감 시간 : 매 주 일요일 23시 59분
- 마감 시간 전까지 해당 주차 5문제을 풀이하여 개인 브랜치에 업로드하고, PR을 제출합니다.
- 각 카테고리에 맞게, 매주 5문제의 공통 문제가 주어집니다.
- - 난이도는 Bronze ~ Silver 문제 입니다.
+ - 난이도는 Silver ~ Gold 문제 입니다.
- PR에 다른 사람의 풀이를 보고 적극적인 커멘트를 남겨주세요
## 🗓️ 파일구조는 다음예시처럼 해주세요
@@ -14,34 +14,79 @@
- main에 푸쉬하는 것을 금지합니다 (전부 날라갈 위험이 있음!!)
- 브랜치명은 다음과 같은 규칙을 지켜주세요!! ex) 이름/week-1, d11210920/week-1
- 이슈는 따로 생성하지 않으셔도 됩니다!! 다만 , PR template을 작성하고 카테고리,제목,링크만 제대로 연결시키고 자신의 README에 추가해주세요
-## ❗️ PR 규칙 및 Commit Message 규칙 ❗️
-### [김동하-1주차 알고리즘 스터디]
-#### Week 01 (25.01.20 ~ 25.01.27)
-| Category | Title | Link |
-| :------: | :---: | :--: |
-| 그래프 | 다리만들기 2 | 🔗 |
-| BFS | 게리맨더링 | 🔗 |
-| 완탐 | 파이프 옮기기 1 | 🔗 |
-| 구현 | 빙고 | 🔗 |
-| DP | 쉬운 계단 수 | 🔗 |
-
-```
-To. Reviewers
-```
### Commit Message
[Baekjoon-문제번호] 문제명
## 주차 별 문제풀이
-https://github.com/tony9402/baekjoon && https://www.acmicpc.net/group/workbook/22697
+
+### Week 10 (25.03.24 ~ 25.03.31)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 그래프 | 최소 스패닝 트리 | 🔗 |
+| 그래프 | 파티 | 🔗 |
+| 그래프 | 쉬운 최단거리 | 🔗 |
+| 그래프 | 경로찾기 | 🔗 |
+| 그래프 | 뱀과 사다리 게임 | 🔗 |
+
+
+### Week 09 (25.03.17 ~ 25.03.23)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 그래프 | 유기농 배추 | 🔗 |
+| 그래프 | DFS와 BFS| 🔗 |
+| 그래프 | 숨바꼭질 | 🔗 |
+| 그래프 | 적록색약 | 🔗 |
+| 그래프 | 플로이드 | 🔗 |
+
+
+### Week 08 (25.03.10 ~ 25.03.16)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 백트래킹 | N과 M (9) | 🔗 |
+| 그래프 | 트리의 부모 찾기| 🔗 |
+| DP | 구간 합 구하기 5 | 🔗 |
+| 그래프 | 이진 검색 트리 | 🔗 |
+| 그래프 | 최단경로 | 🔗 |
+
+
+### Week 07 (25.03.04 ~ 25.03.09)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 백트래킹 | N과 M (4) | 🔗 |
+| 백트래킹 | N과 M (5) | 🔗 |
+| 백트래킹 | N과 M (6) | 🔗 |
+| 백트래킹 | 암호 만들기 | 🔗 |
+| 백트래킹 | 캠프 준비 | 🔗 |
+
+
+### Week 06 (25.02.25 ~ 25.03.03)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 구현 | 막대 | 🔗 |
+| 구현 | 가장 긴 증가하는 부분수열 | 🔗 |
+| 구현 | 로또 | 🔗 |
+| 구현 | N과 M (3) | 🔗 |
+| 구현 | Z | 🔗 |
+
+
+### Week 05 (25.02.17 ~ 25.02.24)
+| Category | Title | Link |
+| :------: | :---: | :--: |
+| 구현 | 비밀번호 발음하기 | 🔗 |
+| 구현 | 임스와 함께하는 미니게임 | 🔗 |
+| 구현 | 쿠키의 신체측정 | 🔗 |
+| 구현 | 등수 구하기 | 🔗 |
+| 구현 | 스위치 켜고 끄기 | 🔗 |
+
### Week 04 (25.02.10 ~ 25.02.17)
| Category | Title | Link |
| :------: | :---: | :--: |
-| 수학 | 더하기 사이클 | 🔗 |
-| 완탐 | 적어도 대부분 배수 | 🔗 |
-| 구현 | 오르막길 | 🔗 |
-| 구현 | 사탕 게임 | 🔗 |
-| 구현 | 슈퍼 마리오 | 🔗 |
+| 수학 | 분수찾기 | 🔗 |
+| 구현 | 색종이 | 🔗 |
+| 구현 | 학번 | 🔗 |
+| 구현 | 단어 정렬 | 🔗 |
+| 구현 | 지뢰찾기 | 🔗 |
diff --git "a/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-11403] \352\262\275\353\241\234 \354\260\276\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-11403] \352\262\275\353\241\234 \354\260\276\352\270\260.java"
new file mode 100644
index 0000000..3e647c0
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-11403] \352\262\275\353\241\234 \354\260\276\352\270\260.java"
@@ -0,0 +1,38 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ int n = Integer.parseInt(br.readLine());
+ int[][] graph = new int[n][n];
+
+ for (int i = 0; i < n; i++) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ for (int j = 0; j < n; j++) {
+ graph[i][j] = Integer.parseInt(st.nextToken());
+ }
+ }
+
+ for (int k = 0; k < n; k++) { // 중간 정점
+ for (int i = 0; i < n; i++) { // 시작 정점
+ for (int j = 0; j < n; j++) { // 도착 정점
+ // k를 거쳐서 i에서 j로 갈 수 있다면 경로 존재 표시
+ if (graph[i][k] == 1 && graph[k][j] == 1) {
+ graph[i][j] = 1;
+ }
+ }
+ }
+ }
+
+ // 결과 출력
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ sb.append(graph[i][j]).append(" ");
+ }
+ sb.append("\n");
+ }
+ System.out.print(sb);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1197] \354\265\234\354\206\214 \354\212\244\355\214\250\353\213\235 \355\212\270\353\246\254.java" "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1197] \354\265\234\354\206\214 \354\212\244\355\214\250\353\213\235 \355\212\270\353\246\254.java"
new file mode 100644
index 0000000..9f91ff3
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1197] \354\265\234\354\206\214 \354\212\244\355\214\250\353\213\235 \355\212\270\353\246\254.java"
@@ -0,0 +1,97 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static Edge[] edgelist;
+ static int[] parents;
+
+ static class Edge implements Comparable{
+ int from, to, w;
+
+ public Edge(int from, int to, int w) {
+ super();
+ this.from = from;
+ this.to = to;
+ this.w = w;
+ }
+
+ @Override
+ public int compareTo(Edge e) {
+ return Integer.compare(this.w, e.w);
+ }
+ }
+
+ public static void main(String[] args)throws IOException {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ edgelist = new Edge[m];
+ for (int i = 0; i < m; i++) {
+
+ st = new StringTokenizer(br.readLine());
+ int a = Integer.parseInt(st.nextToken());
+ int b = Integer.parseInt(st.nextToken());
+ int c = Integer.parseInt(st.nextToken());
+
+ edgelist[i] = new Edge(a,b,c);
+ }
+
+ Arrays.sort(edgelist);
+
+ parents = new int[n + 1];
+ for (int i = 1; i <= n; i++) {
+ parents[i] = i;
+ }
+
+ int result = 0, count = 0;
+ for (Edge e : edgelist) {
+
+ if (union(e.from, e.to)) {
+ result += e.w;
+ if (++count == n-1) {
+ break;
+ }
+ }
+ }
+
+ System.out.println(result);
+ }
+
+ static boolean union(int a, int b) {
+ int aRoot = find(a);
+ int bRoot = find(b);
+
+ if (aRoot == bRoot) {
+ return false;
+ }
+
+ if (aRoot>bRoot) {
+ parents[bRoot] = aRoot;
+ } else {
+ parents[aRoot] = bRoot;
+ }
+ return true;
+ }
+
+ static int find(int a) {
+
+ if (a == parents[a]) {
+ return a;
+ }
+ return parents[a] = find(parents[a]);
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1238] \355\214\214\355\213\260.java" "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1238] \355\214\214\355\213\260.java"
new file mode 100644
index 0000000..45b5659
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-1238] \355\214\214\355\213\260.java"
@@ -0,0 +1,85 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+ // 간선 정보를 저장하는 클래스
+ static class Edge implements Comparable {
+ int to, weight;
+ public Edge(int to, int weight) {
+ this.to = to;
+ this.weight = weight;
+ }
+ public int compareTo(Edge o) {
+ return this.weight - o.weight;
+ }
+ }
+
+ // 다익스트라 알고리즘 구현
+ public static int[] dijkstra(int start, List[] graph, int n) {
+ int INF = Integer.MAX_VALUE;
+ int[] dist = new int[n + 1];
+ Arrays.fill(dist, INF);
+ dist[start] = 0;
+ PriorityQueue pq = new PriorityQueue<>();
+ pq.offer(new Edge(start, 0));
+
+ while (!pq.isEmpty()) {
+ Edge current = pq.poll();
+ int currentNode = current.to;
+ int currentWeight = current.weight;
+
+ if (currentWeight > dist[currentNode]) continue;
+
+ for (Edge edge : graph[currentNode]) {
+ int next = edge.to;
+ int nextCost = currentWeight + edge.weight;
+ if (nextCost < dist[next]) {
+ dist[next] = nextCost;
+ pq.offer(new Edge(next, nextCost));
+ }
+ }
+ }
+ return dist;
+ }
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ int n = Integer.parseInt(st.nextToken());
+ int m = Integer.parseInt(st.nextToken());
+ int x = Integer.parseInt(st.nextToken());
+
+ // 그래프와 역방향 그래프 초기화
+ List[] graph = new ArrayList[n + 1];
+ List[] reverseGraph = new ArrayList[n + 1];
+ for (int i = 1; i <= n; i++) {
+ graph[i] = new ArrayList<>();
+ reverseGraph[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 Edge(v, w));
+ // 역방향 그래프 (각 간선의 방향을 반대로)
+ reverseGraph[v].add(new Edge(u, w));
+ }
+
+ // X에서 각 노드로 가는 최단 경로 (X → i)
+ int[] distFromX = dijkstra(x, graph, n);
+ // 각 노드에서 X로 가는 최단 경로 (i → X)
+ int[] distToX = dijkstra(x, reverseGraph, n);
+
+ // 각 노드별 왕복 시간 중 최댓값 계산
+ int maxTime = 0;
+ for (int i = 1; i <= n; i++) {
+ maxTime = Math.max(maxTime, distToX[i] + distFromX[i]);
+ }
+
+ System.out.println(maxTime);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-14940] \354\211\254\354\232\264 \354\265\234\353\213\250\352\261\260\353\246\254.java" "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-14940] \354\211\254\354\232\264 \354\265\234\353\213\250\352\261\260\353\246\254.java"
new file mode 100644
index 0000000..7e4a18b
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-14940] \354\211\254\354\232\264 \354\265\234\353\213\250\352\261\260\353\246\254.java"
@@ -0,0 +1,77 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+ static class Point {
+ int r, c;
+ Point(int r, int c) {
+ this.r = r;
+ this.c = c;
+ }
+ }
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int n = Integer.parseInt(st.nextToken());
+ int m = Integer.parseInt(st.nextToken());
+
+ int[][] grid = new int[n][m];
+ int[][] dist = new int[n][m];
+ for (int i = 0; i < n; i++){
+ st = new StringTokenizer(br.readLine());
+ for (int j = 0; j < m; j++){
+ grid[i][j] = Integer.parseInt(st.nextToken());
+ dist[i][j] = -1;
+ }
+ }
+
+ // 시작점(값이 2인 칸) 찾기
+ int startR = -1, startC = -1;
+ for (int i = 0; i < n; i++){
+ for (int j = 0; j < m; j++){
+ if (grid[i][j] == 2) {
+ startR = i;
+ startC = j;
+ break;
+ }
+ }
+ if (startR != -1) break;
+ }
+
+ Queue queue = new LinkedList<>();
+ dist[startR][startC] = 0;
+ queue.add(new Point(startR, startC));
+
+ int[] dr = {-1, 1, 0, 0};
+ int[] dc = {0, 0, -1, 1};
+
+ while (!queue.isEmpty()){
+ Point cur = queue.poll();
+ for (int i = 0; i < 4; i++){
+ int nr = cur.r + dr[i];
+ int nc = cur.c + dc[i];
+ if (nr < 0 || nr >= n || nc < 0 || nc >= m) continue;
+ if (grid[nr][nc] == 0 || dist[nr][nc] != -1) continue;
+ // 최단 거리 갱신 및 큐에 추가
+ dist[nr][nc] = dist[cur.r][cur.c] + 1;
+ queue.add(new Point(nr, nc));
+ }
+ }
+
+ // 원래 0인 칸은 0, 접근 가능한 칸은 dist 값
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < n; i++){
+ for (int j = 0; j < m; j++){
+ // 벽인 경우 0 출력
+ if (grid[i][j] == 0) {
+ sb.append("0 ");
+ } else {
+ sb.append(dist[i][j]).append(" ");
+ }
+ }
+ sb.append("\n");
+ }
+ System.out.print(sb.toString());
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-16928] \353\261\200\352\263\274 \354\202\254\353\213\244\353\246\254 \352\262\214\354\236\204.java" "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-16928] \353\261\200\352\263\274 \354\202\254\353\213\244\353\246\254 \352\262\214\354\236\204.java"
new file mode 100644
index 0000000..a0fdc52
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/10\354\243\274\354\260\250/[Baekjoon-16928] \353\261\200\352\263\274 \354\202\254\353\213\244\353\246\254 \352\262\214\354\236\204.java"
@@ -0,0 +1,64 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int n = Integer.parseInt(st.nextToken()); // 사다리 개수
+ int m = Integer.parseInt(st.nextToken()); // 뱀 개수
+
+ // 1부터 100까지의 보드 매핑 (기본적으로 자기 자신으로 매핑)
+ int[] board = new int[101];
+ for (int i = 1; i <= 100; i++) {
+ board[i] = i;
+ }
+
+ for (int i = 0; i < n; i++) {
+ st = new StringTokenizer(br.readLine());
+ int start = Integer.parseInt(st.nextToken());
+ int end = Integer.parseInt(st.nextToken());
+ board[start] = end;
+ }
+
+ for (int i = 0; i < m; i++) {
+ st = new StringTokenizer(br.readLine());
+ int start = Integer.parseInt(st.nextToken());
+ int end = Integer.parseInt(st.nextToken());
+ board[start] = end;
+ }
+
+ // 최소 주사위 굴림 횟수를 저장할 배열 (-1은 아직 방문하지 않았음을 의미)
+ int[] moves = new int[101];
+ Arrays.fill(moves, -1);
+
+ Queue queue = new LinkedList<>();
+ queue.add(1);
+ moves[1] = 0;
+
+ while (!queue.isEmpty()) {
+ int cur = queue.poll();
+
+ if (cur == 100) {
+ System.out.println(moves[cur]);
+ return;
+ }
+
+ for (int dice = 1; dice <= 6; dice++) {
+ int next = cur + dice;
+ if (next > 100) continue; // 100번을 넘어가면 무시
+
+ // 사다리나 뱀이 있는 경우 해당 위치로 이동
+ next = board[next];
+
+ // 아직 방문하지 않은 칸이라면
+ if (moves[next] == -1) {
+ moves[next] = moves[cur] + 1;
+ queue.add(next);
+ }
+ }
+ }
+
+ System.out.println(-1);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-11727] 2xn \355\203\200\354\235\274\353\247\2012.java" "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-11727] 2xn \355\203\200\354\235\274\353\247\2012.java"
new file mode 100644
index 0000000..f9c778d
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-11727] 2xn \355\203\200\354\235\274\353\247\2012.java"
@@ -0,0 +1,31 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main {
+
+ static int[] arr;
+
+ public static void main(String[] args) throws IOException {
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ int n = Integer.parseInt(br.readLine());
+
+ arr = new int[n + 1];
+
+ arr[1] = 1;
+
+ //n이 1 일 경우
+ if (n >= 2) {
+ 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/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-1261] \354\225\214\352\263\240\354\212\244\355\214\237.java" "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-1261] \354\225\214\352\263\240\354\212\244\355\214\237.java"
new file mode 100644
index 0000000..ed3ed12
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-1261] \354\225\214\352\263\240\354\212\244\355\214\237.java"
@@ -0,0 +1,95 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+/*
+ * 미로는 n x m 의 크기
+ * 벽으로는 이동할 수 없음
+ *
+ * 운영진은 모두 같은 방에 있어야 함
+ *
+ * (1,1) 에 있는 운영진이 (n,m) 으로 이동하기 위해 벽을 부수는 최소 횟수
+ *
+ * 0은 빈방, 1은 벽
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ static int[][] map;
+
+ static class Node implements Comparable {
+ int x,y,w;
+ Node(int x, int y, int w) {
+ this.x = x;
+ this.y = y;
+ this.w = w;
+ }
+
+ @Override
+ public int compareTo(Node o) {
+ return this.w - o.w;
+ }
+
+ }
+
+ static int[] dx = {-1,0,1,0};
+ static int[] dy = {0,-1,0,1};
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int m = Integer.parseInt(st.nextToken());
+ int n = Integer.parseInt(st.nextToken());
+
+ map = new int[n][m];
+ for (int i = 0; i < n; i++) {
+ String line = br.readLine();
+ for (int j = 0; j < m; j++) {
+ map[i][j] = line.charAt(j) - '0';
+ }
+ }
+
+ int[][] distance = new int[n][m];
+ for (int i = 0; i < n; i++) {
+ Arrays.fill(distance[i], Integer.MAX_VALUE);
+ }
+
+ distance[0][0] = map[0][0];
+
+ PriorityQueue pQueue = new PriorityQueue<>();
+ pQueue.add(new Node(0, 0, map[0][0]));
+
+ while (!pQueue.isEmpty()) {
+
+ Node next = pQueue.poll();
+
+ if (distance[next.x][next.y] < next.w) continue;
+
+ for (int i = 0; i < 4; i++) {
+ int nx = next.x + dx[i];
+ int ny = next.y + dy[i];
+
+ if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
+
+ if (distance[nx][ny] > distance[next.x][next.y] + map[nx][ny] ) {
+
+
+ distance[nx][ny] = distance[next.x][next.y] + map[nx][ny];
+ pQueue.add(new Node(nx, ny, distance[nx][ny]));
+
+
+ }
+ }
+ }
+ System.out.println(distance[n-1][m-1]);
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-12865] \355\217\211\353\262\224\355\225\234 \353\260\260\353\202\255.java" "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-12865] \355\217\211\353\262\224\355\225\234 \353\260\260\353\202\255.java"
new file mode 100644
index 0000000..a0799ef
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-12865] \355\217\211\353\262\224\355\225\234 \353\260\260\353\202\255.java"
@@ -0,0 +1,48 @@
+/*
+물건 i 안 넣는다
+→ dp[i][w] = dp[i-1][w]
+
+물건 i 넣는다 (단, 무게 여유가 있을 때)
+→ dp[i][w] = dp[i-1][w - weight[i]] + value[i]
+
+두 경우의 수 중 MAX
+dp[i][w] = max(dp[i-1][w], dp[i-1][w - weight[i]] + value[i])
+ */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+
+ 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 + 1];
+ int[] value = new int[n + 1];
+
+ for (int i = 1; i <= n; i++) {
+ st = new StringTokenizer(br.readLine());
+ weight[i] = Integer.parseInt(st.nextToken());
+ value[i] = Integer.parseInt(st.nextToken());
+ }
+ int[][] dp = new int[n + 1][k + 1];
+
+ for (int i = 1; i <= n; i++) {
+ for (int w = 0; w <= k; w++) {
+ if (w >= weight[i]) {
+ dp[i][w] = Math.max(dp[i - 1][w], dp[i - 1][w - weight[i]] + value[i]);
+ } else {
+ dp[i][w] = dp[i - 1][w];
+ }
+ }
+ }
+
+ System.out.println(dp[n][k]);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-9251] LCS.java" "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-9251] LCS.java"
new file mode 100644
index 0000000..edee7f3
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/11\354\243\274\354\260\250/[Baekjoon-9251] LCS.java"
@@ -0,0 +1,37 @@
+/*
+문자가 같으면
+
+dp[i][j] = dp[i-1][j-1] + 1
+
+문자가 다르면
+
+dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+ */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ String line1 = br.readLine();
+ String line2 = br.readLine();
+
+ int[][] dp = new int[line1.length() + 1][line2.length() + 1];
+
+ for (int i = 1; i <= line1.length(); i++) {
+ for (int j = 1; j <= line2.length(); j++) {
+ if (line1.charAt(i - 1) == line2.charAt(j - 1)) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+
+ System.out.println(dp[line1.length()][line2.length()]);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/12\354\243\274\354\260\250/[Baekjoon-2293] \353\217\231\354\240\2041.java" "b/\354\240\225\353\257\274\354\204\234/12\354\243\274\354\260\250/[Baekjoon-2293] \353\217\231\354\240\2041.java"
new file mode 100644
index 0000000..ba6e9ee
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/12\354\243\274\354\260\250/[Baekjoon-2293] \353\217\231\354\240\2041.java"
@@ -0,0 +1,32 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ 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[] coins = new int[n]; // 동전의 가치
+ for (int i = 0; i < n; i++) {
+ coins[i] = Integer.parseInt(br.readLine());
+ }
+
+ int[] dp = new int[k + 1]; // dp[i]: i원을 만드는 경우의 수
+ dp[0] = 1; // 0원을 만드는 경우는 아무 동전도 사용하지 않는 1가지
+
+ // 동전을 하나씩 추가하면서 경우의 수를 계산
+ for (int i = 0; i < n; i++) {
+ for (int j = coins[i]; j <= k; j++) {
+ dp[j] += dp[j - coins[i]];
+ }
+ }
+
+ System.out.println(dp[k]);
+ br.close();
+ }
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-13549] \354\210\250\353\260\224\352\274\255\354\247\2103.java" "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-13549] \354\210\250\353\260\224\352\274\255\354\247\2103.java"
new file mode 100644
index 0000000..64ae4d5
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-13549] \354\210\250\353\260\224\352\274\255\354\247\2103.java"
@@ -0,0 +1,42 @@
+import java.util.*;
+
+public class Main {
+ static final int MAX = 100001;
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int N = sc.nextInt(); // 수빈이 위치
+ int K = sc.nextInt(); // 동생 위치
+
+ int[] dist = new int[MAX];
+ Arrays.fill(dist, -1); // 방문 안 했으면 -1
+
+ Deque deque = new ArrayDeque<>();
+ deque.offer(N);
+ dist[N] = 0;
+
+ while (!deque.isEmpty()) {
+ int now = deque.poll();
+
+ // 순간이동 (0초)
+ if (now * 2 < MAX && dist[now * 2] == -1) {
+ dist[now * 2] = dist[now];
+ deque.offerFirst(now * 2);
+ }
+
+ // -1 이동 (1초)
+ if (now - 1 >= 0 && dist[now - 1] == -1) {
+ dist[now - 1] = dist[now] + 1;
+ deque.offerLast(now - 1);
+ }
+
+ // +1 이동 (1초)
+ if (now + 1 < MAX && dist[now + 1] == -1) {
+ dist[now + 1] = dist[now] + 1;
+ deque.offerLast(now + 1);
+ }
+ }
+
+ System.out.println(dist[K]);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1629] \352\263\261\354\205\210.java" "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1629] \352\263\261\354\205\210.java"
new file mode 100644
index 0000000..8060845
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1629] \352\263\261\354\205\210.java"
@@ -0,0 +1,40 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ public static int a, b, c;
+
+ public static void main(String[] args) throws IOException {
+ init();
+ System.out.println(calc(a, b, c));
+ }
+
+ public static void init() throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ a = Integer.parseInt(st.nextToken());
+ b = Integer.parseInt(st.nextToken());
+ c = Integer.parseInt(st.nextToken());
+ }
+
+ //분할정복을 통해서 거듭제곱 계산
+ public static long calc(long a, long b, long c) {
+ //곱해햐 할 횟수가 1이면 바로 반환
+ if (b == 1) {
+ return a % c;
+ }
+ //지수를 반으로
+ long half = calc(a, b / 2, c);
+ half = (half * half) % c;
+
+ //지수가 짝수일 경우 반환하고 홀수면 a를 한번 더 곱하기
+ if (b % 2 == 0) {
+ return half;
+ } else {
+ return (half * a) % c;
+ }
+ }
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1865] \354\233\234\355\231\200.java" "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1865] \354\233\234\355\231\200.java"
new file mode 100644
index 0000000..58da6c2
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-1865] \354\233\234\355\231\200.java"
@@ -0,0 +1,48 @@
+import java.util.*;
+
+public class Main {
+ static class Edge {
+ int from, to, weight;
+ Edge(int from, int to, int weight) {
+ this.from = from;
+ this.to = to;
+ this.weight = weight;
+ }
+ }
+
+ static final int INF = 100000000;
+ static int N, M, W;
+ static List edges;
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int TC = sc.nextInt();
+
+ while (TC-- > 0) {
+ N = sc.nextInt(); // 지점 수
+ M = sc.nextInt(); // 도로 수
+ W = sc.nextInt(); // 웜홀 수
+
+ edges = new ArrayList<>();
+
+ for (int i = 0; i < M; i++) {
+ int s = sc.nextInt();
+ int e = sc.nextInt();
+ int t = sc.nextInt();
+ // 도로는 양방향
+ edges.add(new Edge(s, e, t));
+ edges.add(new Edge(e, s, t));
+ }
+
+ for (int i = 0; i < W; i++) {
+ int s = sc.nextInt();
+ int e = sc.nextInt();
+ int t = sc.nextInt();
+ // 웜홀은 단방향 & 음수
+ edges.add(new Edge(s, e, -t));
+ }
+
+ if (hasNegativeCycle()) {
+ System.out.println("YES");
+ } else {
+ System.out.println("NO
diff --git "a/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-2206] \353\262\275 \353\266\200\354\210\230\352\263\240 \354\235\264\353\217\231\355\225\230\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-2206] \353\262\275 \353\266\200\354\210\230\352\263\240 \354\235\264\353\217\231\355\225\230\352\270\260.java"
new file mode 100644
index 0000000..f076b67
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-2206] \353\262\275 \353\266\200\354\210\230\352\263\240 \354\235\264\353\217\231\355\225\230\352\270\260.java"
@@ -0,0 +1,81 @@
+import java.util.*;
+
+public class Main {
+ static int N, M;
+ static int[][] map;
+ static boolean[][][] visited;
+ static int[] dx = {1, -1, 0, 0};
+ static int[] dy = {0, 0, 1, -1};
+
+ static class Node {
+ int x, y, breakWall;
+
+ public Node(int y, int x, int breakWall) {
+ this.x = x;
+ this.y = y;
+ this.breakWall = breakWall;
+ }
+ }
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ N = sc.nextInt();
+ M = sc.nextInt();
+ sc.nextLine();
+
+ map = new int[N][M];
+ visited = new boolean[N][M][2];
+
+ for (int i = 0; i < N; i++) {
+ String line = sc.nextLine();
+ for (int j = 0; j < M; j++) {
+ map[i][j] = line.charAt(j) - '0';
+ }
+ }
+
+ System.out.println(bfs());
+ }
+
+ static int bfs() {
+ Queue queue = new LinkedList<>();
+ queue.offer(new Node(0, 0, 0));
+ visited[0][0][0] = true;
+
+ int distance = 1;
+
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+
+ for (int s = 0; s < size; s++) {
+ Node now = queue.poll();
+
+ if (now.y == N - 1 && now.x == M - 1) {
+ return distance;
+ }
+
+ for (int d = 0; d < 4; d++) {
+ int ny = now.y + dy[d];
+ int nx = now.x + dx[d];
+
+ if (ny < 0 || ny >= N || nx < 0 || nx >= M) continue;
+
+ // 다음 칸이 벽이고 아직 벽 안 부쉈으면
+ if (map[ny][nx] == 1 && now.breakWall == 0 && !visited[ny][nx][1]) {
+ visited[ny][nx][1] = true;
+ queue.offer(new Node(ny, nx, 1));
+ }
+
+ // 다음 칸이 빈 칸이고 아직 안 간 경우
+ if (map[ny][nx] == 0 && !visited[ny][nx][now.breakWall]) {
+ visited[ny][nx][now.breakWall] = true;
+ queue.offer(new Node(ny, nx, now.breakWall));
+ }
+ }
+ }
+
+ distance++;
+ }
+
+ return -1;
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-9465] \354\212\244\355\213\260\354\273\244.java" "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-9465] \354\212\244\355\213\260\354\273\244.java"
new file mode 100644
index 0000000..b58906c
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/13\354\243\274\354\260\250/[Baekjoon-9465] \354\212\244\355\213\260\354\273\244.java"
@@ -0,0 +1,33 @@
+import java.util.Scanner;
+
+public class Main {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int T = sc.nextInt();
+
+ while (T-- > 0) {
+ int n = sc.nextInt(); // 스티커 열 수
+ int[][] sticker = new int[2][n + 1];
+ int[][] dp = new int[2][n + 1];
+
+ // 입력 받기
+ for (int i = 0; i < 2; i++) {
+ for (int j = 1; j <= n; j++) {
+ sticker[i][j] = sc.nextInt();
+ }
+ }
+
+ // 초기값 설정
+ dp[0][1] = sticker[0][1];
+ dp[1][1] = sticker[1][1];
+
+ // DP 진행
+ for (int j = 2; j <= n; j++) {
+ dp[0][j] = Math.max(dp[1][j - 1], dp[1][j - 2]) + sticker[0][j];
+ dp[1][j] = Math.max(dp[0][j - 1], dp[0][j - 2]) + sticker[1][j];
+ }
+
+ System.out.println(Math.max(dp[0][n], dp[1][n]));
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-14503]\353\241\234\353\264\207\354\262\255\354\206\214\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-14503]\353\241\234\353\264\207\354\262\255\354\206\214\352\270\260.java"
new file mode 100644
index 0000000..c89dcb2
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-14503]\353\241\234\353\264\207\354\262\255\354\206\214\352\270\260.java"
@@ -0,0 +1,63 @@
+import java.util.Scanner;
+
+public class Main {
+ static int N, M;
+ static int[][] map;
+ static boolean[][] visited;
+ static int[] dx = {-1, 0, 1, 0};
+ static int[] dy = {0, 1, 0, -1};
+ static int count = 0;
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+
+ N = sc.nextInt();
+ M = sc.nextInt();
+ int r = sc.nextInt();
+ int c = sc.nextInt();
+ int d = sc.nextInt();
+
+ map = new int[N][M];
+ visited = new boolean[N][M];
+
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < M; j++) {
+ map[i][j] = sc.nextInt();
+ }
+ }
+
+ clean(r, c, d);
+ System.out.println(count);
+ }
+
+ static void clean(int x, int y, int d) {
+ if (!visited[x][y]) {
+ visited[x][y] = true;
+ count++;
+ }
+
+ for (int i = 0; i < 4; i++) {
+ d = (d + 3) % 4; // 왼쪽으로 회전
+ int nx = x + dx[d];
+ int ny = y + dy[d];
+
+ if (nx >= 0 && ny >= 0 && nx < N && ny < M) {
+ if (map[nx][ny] == 0 && !visited[nx][ny]) {
+ clean(nx, ny, d);
+ return;
+ }
+ }
+ }
+
+ // 네 방향 모두 청소할 수 없을 때 후진
+ int back = (d + 2) % 4;
+ int bx = x + dx[back];
+ int by = y + dy[back];
+
+ if (bx >= 0 && by >= 0 && bx < N && by < M) {
+ if (map[bx][by] == 0) {
+ clean(bx, by, d); // 방향 유지한 채 후진
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-1699] \354\240\234\352\263\261\354\210\230\354\235\230 \355\225\251.java" "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-1699] \354\240\234\352\263\261\354\210\230\354\235\230 \355\225\251.java"
new file mode 100644
index 0000000..b5d82d1
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-1699] \354\240\234\352\263\261\354\210\230\354\235\230 \355\225\251.java"
@@ -0,0 +1,18 @@
+import java.util.Scanner;
+
+public class Main {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int N = sc.nextInt();
+ int[] dp = new int[N + 1];
+
+ for (int i = 1; i <= N; i++) {
+ dp[i] = i; // 최악의 경우 (1^2을 i번 더하는 경우)
+ for (int j = 1; j * j <= i; j++) {
+ dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
+ }
+ }
+
+ System.out.println(dp[N]);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2133] \355\203\200\354\235\274 \354\261\204\354\232\260\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2133] \355\203\200\354\235\274 \354\261\204\354\232\260\352\270\260.java"
new file mode 100644
index 0000000..91d3106
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2133] \355\203\200\354\235\274 \354\261\204\354\232\260\352\270\260.java"
@@ -0,0 +1,26 @@
+import java.util.Scanner;
+
+public class Main {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ int n = sc.nextInt();
+
+ if (n % 2 != 0) {
+ System.out.println(0);
+ return;
+ }
+
+ int[] dp = new int[n + 1];
+ dp[0] = 1;
+ dp[2] = 3;
+
+ for (int i = 4; i <= n; i += 2) {
+ dp[i] = dp[i - 2] * 3;
+ for (int j = i - 4; j >= 0; j -= 2) {
+ dp[i] += dp[j] * 2;
+ }
+ }
+
+ System.out.println(dp[n]);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2629] \354\226\221\355\214\224\354\240\200\354\232\270.java" "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2629] \354\226\221\355\214\224\354\240\200\354\232\270.java"
new file mode 100644
index 0000000..2a11970
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/14\354\243\274\354\260\250/[Baekjoon-2629] \354\226\221\355\214\224\354\240\200\354\232\270.java"
@@ -0,0 +1,57 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+public class Main {
+ static boolean[][] dp;
+ static int[] weights;
+ static int n;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ n = Integer.parseInt(br.readLine()); // 추 개수
+ weights = new int[n];
+ int sum = 0;
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ weights[i] = Integer.parseInt(st.nextToken());
+ sum += weights[i];
+ }
+
+ dp = new boolean[n + 1][sum + 1];
+
+ dfs(0, 0);
+
+ int m = Integer.parseInt(br.readLine()); // 구슬 개수
+ st = new StringTokenizer(br.readLine());
+ StringBuilder sb = new StringBuilder();
+
+ for (int i = 0; i < m; i++) {
+ int bead = Integer.parseInt(st.nextToken());
+ if (bead > sum) {
+ sb.append("N ");
+ } else if (dp[n][bead]) {
+ sb.append("Y ");
+ } else {
+ sb.append("N ");
+ }
+ }
+
+ System.out.println(sb.toString().trim());
+ }
+
+ static void dfs(int idx, int weight) {
+ if (dp[idx][weight]) return; // 이미 방문했으면 리턴
+ dp[idx][weight] = true;
+
+ if (idx == n) return;
+
+ // 다음 추를 사용해서 3가지 경우를 고려:
+ dfs(idx + 1, weight); // 추를 사용 안 함
+ dfs(idx + 1, weight + weights[idx]); // 오른쪽에 추가
+ dfs(idx + 1, Math.abs(weight - weights[idx])); // 왼쪽에 추가
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-14719]\353\271\227\353\254\274.java" "b/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-14719]\353\271\227\353\254\274.java"
new file mode 100644
index 0000000..27517c1
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-14719]\353\271\227\353\254\274.java"
@@ -0,0 +1,46 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int H = Integer.parseInt(st.nextToken());
+ int W = Integer.parseInt(st.nextToken());
+
+ int[] blocks = new int[W];
+ st = new StringTokenizer(br.readLine());
+ for(int i = 0; i < W; i++) {
+ blocks[i] = Integer.parseInt(st.nextToken());
+ }
+
+ int total = 0;
+
+ // 각 위치에서 좌우 최대 높이 찾기
+ for(int i = 1; i < W - 1; i++) {
+ int leftMax = 0;
+ int rightMax = 0;
+
+ // 왼쪽에서 최대 높이 찾기
+ for(int j = 0; j < i; j++) {
+ leftMax = Math.max(leftMax, blocks[j]);
+ }
+
+ // 오른쪽에서 최대 높이 찾기
+ for(int j = i + 1; j < W; j++) {
+ rightMax = Math.max(rightMax, blocks[j]);
+ }
+
+ int minHeight = Math.min(leftMax, rightMax);
+
+ if(minHeight > blocks[i]) {
+ total += minHeight - blocks[i];
+ }
+ }
+
+ System.out.println(total);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-16173] \354\240\220\355\224\204\354\231\225 \354\251\260\353\246\254.java" "b/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-16173] \354\240\220\355\224\204\354\231\225 \354\251\260\353\246\254.java"
new file mode 100644
index 0000000..e921dff
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/15\354\243\274\354\260\250/[Baekjoon-16173] \354\240\220\355\224\204\354\231\225 \354\251\260\353\246\254.java"
@@ -0,0 +1,47 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+public class Main {
+ static int[][] map;
+ static int n;
+ static boolean[][] visited;
+ static boolean canReach = false;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+ n = Integer.parseInt(br.readLine());
+ map = new int[n][n];
+ visited = new boolean[n][n];
+
+ for (int i = 0; i < n; i++) {
+ StringTokenizer 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(canReach ? "HaruHaru" : "Hing");
+ }
+
+ static void dfs(int x, int y) {
+ if (x < 0 || y < 0 || x >= n || y >= n || visited[x][y] || canReach) {
+ return;
+ }
+
+ if (map[x][y] == -1) {
+ canReach = true;
+ return;
+ }
+
+ visited[x][y] = true;
+ int jump = map[x][y];
+
+ dfs(x + jump, y); // 아래로 점프
+ dfs(x, y + jump); // 오른쪽으로 점프
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-10157] \354\236\220\353\246\254\353\260\260\354\240\225.java" "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-10157] \354\236\220\353\246\254\353\260\260\354\240\225.java"
new file mode 100644
index 0000000..a574aa1
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-10157] \354\236\220\353\246\254\353\260\260\354\240\225.java"
@@ -0,0 +1,41 @@
+import java.io.*;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int C = Integer.parseInt(st.nextToken());
+ int R = Integer.parseInt(st.nextToken());
+ int K = Integer.parseInt(br.readLine());
+
+ if (K > R * C) {
+ System.out.println(0);
+ return;
+ }
+
+ boolean[][] visited = new boolean[R][C];
+ int[] dx = {1, 0, -1, 0}; // 아래, 오른쪽, 위, 왼쪽
+ int[] dy = {0, 1, 0, -1};
+
+ int x = 0, y = 0, dir = 0, cnt = 1;
+ visited[x][y] = true;
+
+ while (cnt < K) {
+ int nx = x + dx[dir];
+ int ny = y + dy[dir];
+
+ if (nx >= 0 && nx < R && ny >= 0 && ny < C && !visited[nx][ny]) {
+ x = nx;
+ y = ny;
+ visited[x][y] = true;
+ cnt++;
+ } else {
+ dir = (dir + 1) % 4; // 방향 전환
+ }
+ }
+
+ // 결과는 (y+1, x+1) (열, 행) 순서로 출력!
+ System.out.println((y + 1) + " " + (x + 1));
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-1459] \352\261\267\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-1459] \352\261\267\352\270\260.java"
new file mode 100644
index 0000000..6ab421f
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-1459] \352\261\267\352\270\260.java"
@@ -0,0 +1,35 @@
+import java.io.*;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ long X = Long.parseLong(st.nextToken());
+ long Y = Long.parseLong(st.nextToken());
+ long W = Long.parseLong(st.nextToken());
+ long S = Long.parseLong(st.nextToken());
+
+ long min = Math.min(X, Y);
+ long max = Math.max(X, Y);
+
+ long ans = 0;
+
+
+ if (S < 2 * W) {
+
+ if ((max - min) % 2 == 0) {
+ ans = min * S + (max - min) * S;
+ } else {
+ ans = min * S + (max - min - 1) * S + W;
+ }
+ ans = Math.min(ans, (X + Y) * W);
+ } else {
+
+ ans = (X + Y) * W;
+ }
+
+ System.out.println(ans);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-18111] \353\247\210\354\235\270\355\201\254\353\236\230\355\224\204\355\212\270.java" "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-18111] \353\247\210\354\235\270\355\201\254\353\236\230\355\224\204\355\212\270.java"
new file mode 100644
index 0000000..d0213a1
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-18111] \353\247\210\354\235\270\355\201\254\353\236\230\355\224\204\355\212\270.java"
@@ -0,0 +1,61 @@
+import java.io.*;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ int N = Integer.parseInt(st.nextToken());
+ int M = Integer.parseInt(st.nextToken());
+ int B = Integer.parseInt(st.nextToken());
+
+ int[][] map = new int[N][M];
+ int min = 256;
+ int max = 0;
+
+
+ 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());
+ min = Math.min(min, map[i][j]);
+ max = Math.max(max, map[i][j]);
+ }
+ }
+
+ int resultTime = Integer.MAX_VALUE;
+ int resultHeight = 0;
+
+ // 모든 가능한 높이(최저~최고) 시도
+ for (int h = min; h <= max; h++) {
+ int time = 0;
+ int block = B;
+
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < M; j++) {
+ int diff = map[i][j] - h;
+ if (diff > 0) {
+ // 블록 캐기 (2초씩)
+ time += diff * 2;
+ block += diff;
+ } else if (diff < 0) {
+ // 블록 놓기 (1초씩)
+ time += -diff;
+ block += diff; // diff가 음수
+ }
+ }
+ }
+
+ if (block < 0) continue; // 블록 부족하면 스킵
+
+ // 시간이 같으면 더 높은 높이 선택
+ if (time < resultTime || (time == resultTime && h > resultHeight)) {
+ resultTime = time;
+ resultHeight = h;
+ }
+ }
+
+ System.out.println(resultTime + " " + resultHeight);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-2578] \353\271\231\352\263\240.java" "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-2578] \353\271\231\352\263\240.java"
new file mode 100644
index 0000000..5a39a3d
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/16\354\243\274\354\260\250/[Baekjoon-2578] \353\271\231\352\263\240.java"
@@ -0,0 +1,106 @@
+
+import java.util.*;
+
+public class Main {
+
+ public static int length = 5;
+
+ public static int[][] arr = new int[length][length];
+
+ public static int bingoCount;
+
+ public static int round;
+
+ public static void main(String[] args) {
+
+ Scanner sc = new Scanner(System.in);
+
+ //배열 받기
+ for (int i = 0; i < length; i++) {
+ for (int j = 0; j < length; j++) {
+ arr[i][j] = sc.nextInt();
+ }
+ }
+
+ //사회자가 부르는 수를
+ for (int t = 0; t < length *length; t++) {
+ int currentNum = sc.nextInt();
+ round++;
+
+ for (int i = 0; i < length; i++) {
+ for (int j = 0; j < length; j++) {
+ if (arr[i][j] == currentNum) {
+ arr[i][j] = -1;
+ }
+ }
+ }
+
+ countBingo();
+
+ if (bingoCount >= 3) {
+ System.out.println(round);
+ return;
+ }
+ }
+ }
+
+ private static void countBingo() {
+ bingoCount = 0;
+
+
+
+ //가로
+ for (int i = 0; i < length; i++) {
+ boolean isRowBingo = true;
+ for (int j = 0; j < length; j++) {
+ if(arr[i][j] != -1) {
+ isRowBingo = false;
+ break;
+ }
+ }
+ if (isRowBingo) {
+ bingoCount++;
+ }
+ }
+
+ //세로
+ for (int i = 0; i < length; i++) {
+ boolean isColBingo = true;
+ for (int j = 0; j < length; j++) {
+ if(arr[j][i] != -1) {
+ isColBingo = false;
+ break;
+ }
+ }
+ if (isColBingo) {
+ bingoCount++;
+ }
+ }
+
+
+ //오른쪽 대각선
+ boolean isXyBingo = true;
+ for (int i = 0; i < length; i++) {
+ if(arr[i][length-i-1] != -1) {
+ isXyBingo = false;
+ break;
+ }
+ }
+ if (isXyBingo) {
+ bingoCount++;
+ }
+
+ //왼쪽 대각선
+ boolean isyxBingo = true;
+ for (int i = 0; i < length; i++) {
+ if(arr[i][i] != -1) {
+ isyxBingo = false;
+ break;
+ }
+ }
+ if (isyxBingo) {
+ bingoCount++;
+ }
+
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1205] \353\223\261\354\210\230 \352\265\254\355\225\230\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1205] \353\223\261\354\210\230 \352\265\254\355\225\230\352\270\260.java"
new file mode 100644
index 0000000..7a97df1
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1205] \353\223\261\354\210\230 \352\265\254\355\225\230\352\270\260.java"
@@ -0,0 +1,60 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static int[] arr;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int n = Integer.parseInt(st.nextToken());
+ int newScore = Integer.parseInt(st.nextToken());
+ int p = Integer.parseInt(st.nextToken());
+
+ if (n == 0) {
+ bw.write("1");
+ bw.flush();
+ bw.close();
+ br.close();
+ return;
+ }
+
+ arr = new int[n];
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ arr[i] = Integer.parseInt(st1.nextToken());
+ }
+
+ if (n == p && newScore <= arr[n - 1]) {
+ bw.write("-1");
+ bw.flush();
+ bw.close();
+ br.close();
+ return;
+ }
+
+ int count = 0;
+ for (int i = 0; i < n; i++) {
+ if (newScore < arr[i]) {
+ count++;
+ }
+ }
+
+ if (count + 1 > p) {
+ bw.write("-1");
+ } else {
+ bw.write(String.valueOf(count + 1));
+ }
+
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1244] \354\212\244\354\234\204\354\271\230 \354\274\234\352\263\240 \353\201\204\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1244] \354\212\244\354\234\204\354\271\230 \354\274\234\352\263\240 \353\201\204\352\270\260.java"
new file mode 100644
index 0000000..85feca2
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-1244] \354\212\244\354\234\204\354\271\230 \354\274\234\352\263\240 \353\201\204\352\270\260.java"
@@ -0,0 +1,63 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static int switches, students;
+ static int[] switchStatus;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ switches = Integer.parseInt(br.readLine());
+ switchStatus = new int[switches + 1];
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ for (int i = 1; i <= switches; i++) {
+ switchStatus[i] = Integer.parseInt(st.nextToken());
+ }
+ //학생 수
+ students = Integer.parseInt(br.readLine());
+
+ for (int i = 0; i < students; i++) {
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ int gender = Integer.parseInt(st1.nextToken());
+ int num = Integer.parseInt(st1.nextToken());
+
+ if (gender == 1) { //남자일 경우
+ for (int j = num; j <= switches; j += num) {
+ switchStatus[j] = (switchStatus[j] == 0) ? 1 : 0;
+ }
+ } else if (gender == 2) {
+ //좌우 대칭 확인
+ int pos = num;
+ switchStatus[pos] = (switchStatus[pos] == 0) ? 1 : 0;
+ int k = 1;
+
+ //좌우 범위 체크
+ while (pos - k >= 1 && pos + k <= switches && switchStatus[pos - k] == switchStatus[pos + k]) {
+
+ switchStatus[pos - k] = (switchStatus[pos - k] == 0) ? 1 : 0;
+ switchStatus[pos + k] = (switchStatus[pos + k] == 0) ? 1 : 0;
+ k++;
+ }
+ }
+ }
+ for (int i = 1; i <= switches; i++) {
+ bw.write(switchStatus[i] + " ");
+ if (i % 20 == 0) {
+ bw.newLine();
+ }
+ }
+
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-20125] \354\277\240\355\202\244\354\235\230 \354\213\240\354\262\264 \354\270\241\354\240\225.java" "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-20125] \354\277\240\355\202\244\354\235\230 \354\213\240\354\262\264 \354\270\241\354\240\225.java"
new file mode 100644
index 0000000..eef6c58
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-20125] \354\277\240\355\202\244\354\235\230 \354\213\240\354\262\264 \354\270\241\354\240\225.java"
@@ -0,0 +1,83 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+public class Main {
+
+ static char[][] map;
+
+ static int heartRow, heartCol;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ int n = Integer.parseInt(br.readLine());
+
+ map = new char[n][n];
+ for (int i = 0; i < n; i++) {
+ String line = br.readLine();
+ for (int j = 0; j < n; j++) {
+ map[i][j] = line.charAt(j);
+ }
+ }
+ //심장위치
+ heartRow = 0;
+ heartCol = 0;
+ for (int i = 1; i < n - 1; i++) {
+ for (int j = 1; j < n - 1; j++) {
+ if (map[i][j] == '*') {
+ if (map[i - 1][j] == '*' && map[i + 1][j] == '*' && map[i][j - 1] == '*' && map[i][j + 1] == '*') {
+ heartRow = i;
+ heartCol = j;
+ break;
+ }
+ }
+ }
+ }
+ //왼팔
+ int leftarm = 0;
+ for (int i = heartCol - 1; i >= 0; i--) {
+ if (map[heartRow][i] == '*') {
+ leftarm++;
+ }
+ }
+ //오른팔
+ int rightarm = 0;
+ for (int i = heartCol + 1; i < n; i++) {
+ if (map[heartRow][i] == '*') {
+ rightarm++;
+ }
+ }
+
+ //허리
+ int back = 0;
+ for (int i = heartRow + 1; i < n; i++) {
+ if (map[i][heartCol] == '*') {
+ back++;
+ }
+ }
+
+ int leftleg = 0;
+ for (int i = heartRow + back; i < n; i++) {
+ if (map[i][heartCol - 1] == '*') {
+ leftleg++;
+ }
+ }
+
+ int rightleg = 0;
+ for (int i = heartRow + back; i < n; i++) {
+ if (map[i][heartCol + 1] == '*') {
+ rightleg++;
+ }
+ }
+
+ bw.write((heartRow + 1) + " " + (heartCol + 1) + "\n");
+ bw.write(leftarm + " " + rightarm + " " + back + " " + leftleg + " " + rightleg + "\n");
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-25757] \354\236\204\354\212\244\354\231\200 \355\225\250\352\273\230\355\225\230\353\212\224 \353\257\270\353\213\210\352\262\214\354\236\204.java" "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-25757] \354\236\204\354\212\244\354\231\200 \355\225\250\352\273\230\355\225\230\353\212\224 \353\257\270\353\213\210\352\262\214\354\236\204.java"
new file mode 100644
index 0000000..fb9fede
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-25757] \354\236\204\354\212\244\354\231\200 \355\225\250\352\273\230\355\225\230\353\212\224 \353\257\270\353\213\210\352\262\214\354\236\204.java"
@@ -0,0 +1,45 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static int target;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ int n = Integer.parseInt(st.nextToken());
+ String s = st.nextToken();
+
+ Set arr = new HashSet<>();
+
+ if (s.equals("Y")) {
+ target = 1;
+ } else if (s.equals("F")) {
+ target = 2;
+ } else if (s.equals("O")) {
+ target = 3;
+ }
+
+ for (int i = 0; i < n; i++) {
+ arr.add(br.readLine());
+ }
+
+ int arrSize = arr.size();
+ int ans = arrSize / target;
+ bw.write(ans + "\n");
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-4659] \353\271\204\353\260\200\353\262\210\355\230\270 \353\260\234\354\235\214\355\225\230\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-4659] \353\271\204\353\260\200\353\262\210\355\230\270 \353\260\234\354\235\214\355\225\230\352\270\260.java"
new file mode 100644
index 0000000..970b84b
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/5\354\243\274\354\260\250/[Baekjoon-4659] \353\271\204\353\260\200\353\262\210\355\230\270 \353\260\234\354\235\214\355\225\230\352\270\260.java"
@@ -0,0 +1,72 @@
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+//모음(a,e,i,o,u) 하나를 반드시 포함하여야 한다.
+//모음이 3개 혹은 자음이 3개 연속으로 오면 안 된다.
+//같은 글자가 연속적으로 두번 오면 안되나, ee 와 oo는 허용한다.
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ while (true) {
+ String input = br.readLine(); //입력받기
+
+ if (input.equals("end")) {
+ break; //종료조건
+ }
+
+ boolean isAcceptable = true;
+ boolean firstOption = false;
+
+ char prev = ' ';
+
+ int vowelCount = 0;
+ int consonantCount = 0;
+ for (int i = 0; i < input.length(); i++) {
+ char c = input.charAt(i);
+ if ("aeiou".indexOf(c) != -1) {
+ firstOption = true;
+ vowelCount++;
+ consonantCount = 0;
+ } else {
+ consonantCount++;
+ vowelCount = 0;
+ }
+
+ if (vowelCount >= 3 || consonantCount >= 3) {
+ isAcceptable = false;
+ break;
+ }
+
+ //첫문자가 아닌 다음 문자부터 중복 검사 시작
+ if (i >= 1) {
+ if (prev == c && prev != 'e' && prev != 'o') {
+ isAcceptable = false;
+ break;
+ }
+ }
+ prev = c; //prev 갱신
+ }
+
+ if (!firstOption) {
+ isAcceptable = false;
+ }
+
+ if (isAcceptable) {
+ bw.write("<" + input + "> " + "is acceptable." + "\n");
+ } else {
+ bw.write("<" + input + "> " + "is not acceptable." + "\n");
+ }
+
+ }
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-1094] \353\247\211\353\214\200\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-1094] \353\247\211\353\214\200\352\270\260.java"
new file mode 100644
index 0000000..efb52f6
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-1094] \353\247\211\353\214\200\352\270\260.java"
@@ -0,0 +1,57 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+/*
+ * 1. 64cm 길이의 막대를 가지고 있음
+ *
+ * 2. 길이가 x인 막대가 가지고 싶어 자르고 붙여서 길이가 x 인 막대를 가지고 싶음
+ *
+ * 3. 막대를 자르기 가장 쉬운 방법은 절반으로 자르는 것
+ *
+ * 3-1 막대의 길이를 모두 더하기 이 때 합이 x 보다 크거나 같으면, 아래 과정 반복
+ *
+ * 3-1-1 가지고 있는 막대 중 길이가 가장 짧은 것을 절반으로 자르기
+ *
+ * 3-1-2 위에서 자른 막대의 절반 중 하나를 버리고 남아있는 막대의 길이의 합이 >= x -> 자른 막대의 절반 중 하나 버림
+ *
+ * 3-2 남아있는 모든 막대를 풀로 붙여서 x를 만들기
+ *
+ * 4. x가 주어졌을 때, 몇 개의 막대를 풀로 붙여서 x cm를 만들 수 있는지 구하는 프로그램
+ *
+ *
+ * x <= 64 자연수
+ */
+
+public class Main {
+
+ static int x, ans;
+
+ static int stick = 64;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ //원하는 막대기 길이
+ x = Integer.parseInt(br.readLine());
+
+ String str = Integer.toBinaryString(x);
+
+ ans = 0;
+ for (int i = 0; i < str.length(); i++) {
+ if (str.charAt(i) == '1') {
+ ans++;
+ }
+ }
+
+ bw.write(String.valueOf(ans));
+ bw.flush();
+ br.close();
+ bw.close();
+
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-11053] \352\260\200\354\236\245 \352\270\264 \354\246\235\352\260\200\355\225\230\353\212\224 \353\266\200\353\266\204 \354\210\230\354\227\264.java" "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-11053] \352\260\200\354\236\245 \352\270\264 \354\246\235\352\260\200\355\225\230\353\212\224 \353\266\200\353\266\204 \354\210\230\354\227\264.java"
new file mode 100644
index 0000000..e0180ae
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-11053] \352\260\200\354\236\245 \352\270\264 \354\246\235\352\260\200\355\225\230\353\212\224 \353\266\200\353\266\204 \354\210\230\354\227\264.java"
@@ -0,0 +1,53 @@
+/*
+수열 a 가 주어졌을 때, 가장 긴 증가하는 부분 수열
+1. 입력
+ 1-1 첫째 줄에 수열 a의 크기 n
+ 1-2 둘째 줄에는 수열 a를 이루고 있는 n만큼의 원소가 주어짐
+
+2. 반복문을 돌면서 현재 선택된 원소를 마지막으로 하는 부분 수열의 최대 길이를 구하고
+가장 큰 값을 갱신해가며 답 구하기
+
+ */
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ static int n, count;
+ static int[] arr, dp;
+
+ public static void main(String[] args) throws IOException {
+ n = Integer.parseInt(br.readLine());
+
+ arr = new int[n];
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ arr[i] = Integer.parseInt(st.nextToken());
+ }
+
+ dp = new int[n];
+ count = 0;
+
+ for (int i = 0; i < n; i++) {
+ dp[i] = 1;
+ for (int j = 0; j < i; j++) {
+ if (arr[i] > arr[j]) {
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ count = Math.max(count, dp[i]);
+ }
+
+ bw.write(count + "\n");
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-15651] N\352\263\274 M(3).java" "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-15651] N\352\263\274 M(3).java"
new file mode 100644
index 0000000..1dd52c4
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-15651] N\352\263\274 M(3).java"
@@ -0,0 +1,65 @@
+/*
+1. 입력
+ 1-1 첫째 줄에 공백으로 구분해서 n과 m 주어짐
+2. 같은 수를 여러 번 골라도 되는 중복 허용
+ 2-1 기저조건: 수를 뽑은 배열이 m이 되는 순간 종료
+ 2-2 진행로직: 기존 순열 알고리즘에서 선택된 수를 제외한 boolean 배열을
+ 제거하고 문제 풀기
+
+ */
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ static int n, m;
+
+ static int[] arr, ans;
+
+ public static void main(String[] args) throws IOException {
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ //1-1 첫째 줄에 공백으로 구분해서 n과 m 주어짐
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ arr = new int[n];
+ for (int i = 0; i < n; i++) {
+ arr[i] = i + 1;
+ }
+
+ ans = new int[m];
+
+ perm(0);
+
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void perm(int cnt) throws IOException {
+
+ //기저조건
+ if (cnt == m) {
+ for (int i = 0; i < m; i++) {
+ bw.write(String.valueOf(ans[i]) + " ");
+ }
+ bw.write("\n");
+ return;
+ }
+
+ for (int i = 0; i < n; i++) {
+ ans[cnt] = arr[i];
+ perm(cnt + 1);
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-6603] \353\241\234\353\230\220.java" "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-6603] \353\241\234\353\230\220.java"
new file mode 100644
index 0000000..a788761
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/6\354\243\274\354\260\250/[Baekjoon-6603] \353\241\234\353\230\220.java"
@@ -0,0 +1,73 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+/*
+1. 입력
+ 1-1 한줄에 테스트 케이스의 숫자가 주어짐
+ 1-2 주어진 숫자 만큼 원소를 입력받음
+ 1-3 입력값이 0이면 종료
+
+2. 조합문제
+ 2-1 주어진 원소 수 중 중복되지 않는 가능한 모든 수를 출력
+ 2-1-1 기저조건: 선택된 수가 6과 같으면 종료
+ 2-1-2 진행 로직: 조합 알고리즘을 사용해 cnt와 start 매개변수로 재귀 호출
+
+ */
+
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ static int k;
+ static int n = 6;
+ static int[] s, ans;
+
+ public static void main(String[] args) throws IOException {
+
+ while (true) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ k = Integer.parseInt(st.nextToken());
+
+ //입력 종료 조건
+ if (k == 0) {
+ break;
+ }
+ s = new int[k];
+ for (int i = 0; i < k; i++) {
+ s[i] = Integer.parseInt(st.nextToken());
+ }
+
+ ans = new int[n];
+ combi(0, 0);
+ bw.write("\n");
+ }
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+
+ static void combi(int cnt, int start) throws IOException {
+
+ //기저조건
+ if (cnt == n) {
+ for (int i = 0; i < n; i++) {
+ bw.write(String.valueOf(ans[i]) + " ");
+ }
+ bw.write("\n");
+ return;
+ }
+
+ for (int i = start; i < k; i++) {
+ ans[cnt] = s[i];
+ combi(cnt + 1, i + 1);
+ }
+ }
+
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15652] N\352\263\274 M (4).java" "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15652] N\352\263\274 M (4).java"
new file mode 100644
index 0000000..0e496e8
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15652] N\352\263\274 M (4).java"
@@ -0,0 +1,56 @@
+import java.util.*;
+import java.io.*;
+
+/*
+ * 순서가 상관 있음 => 조합 알고리즘
+ * 같은 수를 골라도 괜찮음
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static int[] input,res;
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ input = new int[n];
+ res = new int[m];
+
+ for (int i = 0; i < input.length; i++) {
+ input[i] = i + 1;
+ }
+
+ combi(0,0);
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void combi(int cnt, int start) {
+
+ if (cnt == m) {
+ for (int i = 0; i < res.length; i++) {
+ sb.append(res[i]).append(" ");
+ }
+ sb.append("\n");
+ return;
+ }
+
+ for (int i = start; i < input.length; i++) {
+ res[cnt] = input[i];
+ combi(cnt +1, i);
+ }
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15654] N\352\263\274 M (5).java" "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15654] N\352\263\274 M (5).java"
new file mode 100644
index 0000000..2a7f277
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15654] N\352\263\274 M (5).java"
@@ -0,0 +1,67 @@
+import java.util.*;
+import java.io.*;
+
+
+/*
+ * 순서가 의미 있음 -> 순열
+ * 중복 허용 안함
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static int[] input, res;
+ static boolean[] isSelected;
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ input = new int[n];
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ input[i] = Integer.parseInt(st1.nextToken());
+ }
+
+ Arrays.sort(input);
+
+ res = new int[m];
+ isSelected = new boolean[n];
+
+ perm(0);
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void perm(int cnt) {
+
+ if (cnt == m) {
+ for (int i = 0; i < res.length; i++) {
+ sb.append(res[i]).append(" ");
+ }
+ sb.append("\n");
+ return;
+ }
+
+ for (int i = 0; i < input.length; i++) {
+
+ if (!isSelected[i]) {
+ isSelected[i] = true;
+ res[cnt] = input[i];
+ perm(cnt+1);
+ isSelected[i] = false;
+ }
+ }
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15655] N\352\263\274 M (6).java" "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15655] N\352\263\274 M (6).java"
new file mode 100644
index 0000000..db3976e
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-15655] N\352\263\274 M (6).java"
@@ -0,0 +1,58 @@
+import java.util.*;
+import java.io.*;
+
+/*
+ * 순서의미 없음 -> 조합 알고리즘
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static int[] res, input;
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ input = new int[n];
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ input[i] = Integer.parseInt(st1.nextToken());
+ }
+
+ Arrays.sort(input);
+ res = new int[m];
+
+ combi(0,0);
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void combi(int cnt, int start) {
+
+ if (cnt == m) {
+ for (int i = 0; i < m; i++) {
+ sb.append(res[i]).append(" ");
+ }
+ sb.append("\n");
+ return;
+ }
+
+ for (int i = start; i < n; i++) {
+
+ res[cnt] = input[i];
+ combi(cnt + 1, i + 1);
+ }
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-16938] \354\272\240\355\224\204 \354\244\200\353\271\204.java" "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-16938] \354\272\240\355\224\204 \354\244\200\353\271\204.java"
new file mode 100644
index 0000000..1f269a4
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-16938] \354\272\240\355\224\204 \354\244\200\353\271\204.java"
@@ -0,0 +1,77 @@
+import java.util.*;
+import java.io.*;
+/*
+ * 캠프에 사용할 문제는 2문제 이상
+ * 문제 난이도 합은 l보다 크거나 같고 r보다 작거나 같아야 한다
+ * 가장어려운 문제와 쉬운 문제의 난이도 차이는 x보다 크거나 같아야 한다
+ *
+ * 1. 입력
+ * 1-1 첫줄에 n,l,r,x
+ * 1-2 두번째 줄에 n개의 난이도가 정수로 주어짐
+ *
+ * 2. 로직
+ * 2-1 원소의 합을 구해야하기 때문에, 순서의미 없음 -> 조합
+ * 2-2 메서드 구현 시에 위 조건 추가하기
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,l,r,x;
+ static int[] input, res;
+ static int count = 0;
+
+ public static void main(String[] args) throws IOException{
+
+ 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());
+
+ input = new int[n];
+ res = new int[n];
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ input[i] = Integer.parseInt(st1.nextToken());
+ }
+
+ Arrays.sort(input);
+
+ combi(0,0);
+
+ bw.write(String.valueOf(count));
+ bw.flush();
+ br.close();
+ bw.close();
+ }
+
+ static void combi(int cnt, int start) {
+
+ if (start == n) {
+ if (cnt >= 2) {
+ int sum = 0;
+ int minVal = Integer.MAX_VALUE;
+ int maxVal = Integer.MIN_VALUE;
+
+ for (int i = 0; i < cnt; i++) {
+ sum += res[i];
+ minVal = Math.min(minVal, res[i]);
+ maxVal = Math.max(maxVal, res[i]);
+ }
+
+ if (sum >= l && sum <=r && (maxVal - minVal) >=x ) {
+ count++;
+ }
+ }
+ return;
+ }
+
+ res[cnt] = input[start];
+ combi(cnt+1, start +1);
+ combi(cnt, start+1);
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-1759] \354\225\224\355\230\270 \353\247\214\353\223\244\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-1759] \354\225\224\355\230\270 \353\247\214\353\223\244\352\270\260.java"
new file mode 100644
index 0000000..92ef6ad
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/7\354\243\274\354\260\250/[Baekjoon-1759] \354\225\224\355\230\270 \353\247\214\353\223\244\352\270\260.java"
@@ -0,0 +1,85 @@
+/*
+ * 서로다른 l개의 알파벳 소문자들로 구성, 최소 한개의 모음과 최소 두개의 자음으로 구성
+ * 알파벳이 암호에서 증가하는 순서
+ * 1. 입력
+ * 1-1 첫줄에는 l, c 가 주어짐
+ * 1-2 c개의 문자들이 공백으로 구분되어 주어짐
+ *
+ * 2. 진행로직
+ * 2-1 순서의미 없음 -> 조합 알고리즘
+ * 2-2 최소 한개의 모음, 두개의 자음으로 구성
+ *
+ */
+
+import java.util.*;
+import java.io.*;
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int l,c;
+ static char[] input, res;
+
+ public static void main(String[] args) throws IOException {
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ l = Integer.parseInt(st.nextToken());
+ c = Integer.parseInt(st.nextToken());
+
+ res = new char[l];
+ input = new char[c];
+
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < c; i++) {
+ input[i] = st1.nextToken().charAt(0);
+ }
+
+ Arrays.sort(input);
+
+ combi(0,0);
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+
+
+ }
+
+ static void combi(int cnt, int start) {
+
+ if (cnt == l) {
+
+ int vowelCount = 0;
+ int letterCount = 0;
+
+ for (int i = 0; i < l; i++) {
+
+ if (res[i] == 'a' || res[i] == 'e' || res[i] == 'o' || res[i] == 'u' || res[i] == 'i') {
+ vowelCount++;
+ } else {
+ letterCount++;
+ }
+ }
+
+ if ( vowelCount >= 1 && letterCount >= 2) {
+ for (int i = 0; i < l; i++) {
+ sb.append(res[i]);
+ }
+ sb.append("\n");
+ }
+ return;
+ }
+
+ for (int i = start; i < c; i++) {
+ res[cnt] = input[i];
+ combi(cnt+1, i + 1);
+ }
+
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11660] \352\265\254\352\260\204 \355\225\251 \352\265\254\355\225\230\352\270\260 5.java" "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11660] \352\265\254\352\260\204 \355\225\251 \352\265\254\355\225\230\352\270\260 5.java"
new file mode 100644
index 0000000..8fa16cc
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11660] \352\265\254\352\260\204 \355\225\251 \352\265\254\355\225\230\352\270\260 5.java"
@@ -0,0 +1,48 @@
+import java.util.*;
+import java.io.*;
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static int[][] map, sum;
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+
+ map = new int[n+1][n+1];
+ sum = 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++) {
+ map[i][j] = Integer.parseInt(st.nextToken());
+ sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + map[i][j];
+ }
+ }
+
+ 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 result = sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1] + sum[x1-1][y1-1];
+ sb.append(result + "\n");
+ }
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11725] \355\212\270\353\246\254\354\235\230 \353\266\200\353\252\250 \354\260\276\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11725] \355\212\270\353\246\254\354\235\230 \353\266\200\353\252\250 \354\260\276\352\270\260.java"
new file mode 100644
index 0000000..f5519f0
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-11725] \355\212\270\353\246\254\354\235\230 \353\266\200\353\252\250 \354\260\276\352\270\260.java"
@@ -0,0 +1,59 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static ArrayList[] tree;
+ static int n;
+ static int[] parent;
+ static boolean[] visited;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ n = Integer.parseInt(br.readLine());
+
+ tree = new ArrayList[n + 1];
+ for (int i = 1; i <= n; i++) {
+ tree[i] = new ArrayList<>();
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int a = Integer.parseInt(st.nextToken());
+ int b = Integer.parseInt(st.nextToken());
+ tree[a].add(b);
+ tree[b].add(a);
+ }
+
+ parent = new int[n + 1];
+ visited = new boolean[n + 1];
+
+ dfs(1);
+
+ for (int i = 2; i < parent.length; i++) {
+ System.out.println(parent[i]);
+ }
+
+
+ }
+
+ static void dfs(int current) {
+
+ visited[current] = true;
+
+ for (int next : tree[current]) {
+
+ if (!visited[next]) {
+ parent[next] = current;
+ dfs(next);
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-15663] N\352\263\274 M (9).java" "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-15663] N\352\263\274 M (9).java"
new file mode 100644
index 0000000..79bbc3f
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-15663] N\352\263\274 M (9).java"
@@ -0,0 +1,68 @@
+import java.util.*;
+import java.io.*;
+
+/*
+ * 순서 의미 잇음 -> 순열 알고리즘
+ * 집합에 같은 숫자 처리 필요
+ */
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int n,m;
+ static int[] input,res;
+ static boolean[] isSelected;
+
+ public static void main(String[] args) throws IOException{
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+
+ input = new int[n];
+ StringTokenizer st1 = new StringTokenizer(br.readLine());
+ for (int i = 0; i < n; i++) {
+ input[i] = Integer.parseInt(st1.nextToken());
+ }
+
+ Arrays.sort(input);
+ res = new int[m];
+ isSelected = new boolean[n];
+
+ perm(0);
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void perm(int cnt) {
+
+ if (cnt == m) {
+ for (int i = 0; i < m; i++) {
+ sb.append(res[i]).append(" ");
+ }
+ sb.append("\n");
+ return;
+ }
+
+ for (int i = 0; i < n; i++) {
+
+ if (!isSelected[i]) {
+
+ if (i > 0 && input[i] == input[i-1] && !isSelected[i-1]) continue;
+
+
+ isSelected[i] = true;
+ res[cnt] = input[i];
+ perm(cnt+1);
+ isSelected[i] = false;
+ }
+ }
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-5639] \354\235\264\354\247\204 \352\262\200\354\203\211 \355\212\270\353\246\254.java" "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-5639] \354\235\264\354\247\204 \352\262\200\354\203\211 \355\212\270\353\246\254.java"
new file mode 100644
index 0000000..383ea7d
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/8\354\243\274\354\260\250/[Baekjoon-5639] \354\235\264\354\247\204 \352\262\200\354\203\211 \355\212\270\353\246\254.java"
@@ -0,0 +1,71 @@
+import java.util.*;
+import java.io.*;
+
+class Node {
+ int value;
+ Node left, right;
+
+ Node(int value) {
+ this.value = value;
+ this.left = null;
+ this.right = null;
+ }
+}
+
+public class Main {
+
+ static Node root;
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ public static void main(String[] args) throws IOException{
+
+ root = new Node(Integer.parseInt(br.readLine()));
+
+ String input;
+ while ((input = br.readLine()) != null && !input.isEmpty()) {
+ insert(root, Integer.parseInt(input));
+ }
+
+ postorder(root);
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void insert(Node node, int value) {
+
+ if( value < node.value) {
+
+ if (node.left == null) {
+ node.left = new Node(value);
+ } else {
+ insert(node.left, value);
+ }
+ } else {
+
+ if (node.right == null) {
+ node.right = new Node(value);
+ } else {
+ insert(node.right, value);
+ }
+ }
+ }
+
+ static void postorder(Node node) {
+
+ if (node == null) {
+ return;
+ }
+ postorder(node.left);
+ postorder(node.right);
+ sb.append(node.value).append("\n");
+
+ }
+
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-10026] \354\240\201\353\241\235\354\203\211\354\225\275.java" "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-10026] \354\240\201\353\241\235\354\203\211\354\225\275.java"
new file mode 100644
index 0000000..951fa8e
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-10026] \354\240\201\353\241\235\354\203\211\354\225\275.java"
@@ -0,0 +1,77 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main {
+ static int N;
+ static char[][] grid;
+ static boolean[][] visited;
+
+ static int[] dx = {-1, 1, 0, 0};
+ static int[] dy = {0, 0, -1, 1};
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ N = Integer.parseInt(br.readLine());
+ grid = new char[N][N];
+
+ for (int i = 0; i < N; i++) {
+ String line = br.readLine();
+ grid[i] = line.toCharArray();
+ }
+
+ // 일반인의 영역 수 계산 (정확한 색 구분)
+ visited = new boolean[N][N];
+ int normalCount = 0;
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ if (!visited[i][j]) {
+ normalCount++;
+ dfs(i, j, grid[i][j]);
+ }
+ }
+ }
+
+ // 적록색약인의 영역 수 계산
+ // 먼저 원본 격자를 복사한 후, 'G'를 'R'로 변경하여 R과 G를 동일하게 처리
+ char[][] gridForColorblind = new char[N][N];
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ // 'G'는 'R'로 변경
+ gridForColorblind[i][j] = (grid[i][j] == 'G') ? 'R' : grid[i][j];
+ }
+ }
+
+ // gridForColorblind를 새로운 탐색 대상 격자로 사용
+ grid = gridForColorblind;
+ visited = new boolean[N][N];
+ int colorblindCount = 0;
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ if (!visited[i][j]) {
+ colorblindCount++;
+ dfs(i, j, grid[i][j]);
+ }
+ }
+ }
+
+ // 일반인 영역 수와 적록색약인 영역 수
+ System.out.println(normalCount + " " + colorblindCount);
+ }
+
+ // (x, y) 위치에서 시작하여 color와 같은 영역을 탐색
+ static void dfs(int x, int y, char color) {
+ visited[x][y] = true;
+ for (int i = 0; i < 4; i++) {
+ int nx = x + dx[i];
+ int ny = y + dy[i];
+ // 격자 범위 내에 있는지 확인
+ if (nx >= 0 && nx < N && ny >= 0 && ny < N) {
+ // 아직 방문하지 않았고, 색이 동일하면 DFS 진행
+ if (!visited[nx][ny] && grid[nx][ny] == color) {
+ dfs(nx, ny, color);
+ }
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1012] \354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224.java" "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1012] \354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224.java"
new file mode 100644
index 0000000..3794da7
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1012] \354\234\240\352\270\260\353\206\215 \353\260\260\354\266\224.java"
@@ -0,0 +1,72 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static final StringBuilder sb = new StringBuilder("");
+
+ static int t, m, n, k;
+ static int[][] map;
+ static boolean[][] visited;
+ static int[] dx = {-1, 0, 1, 0};
+ static int[] dy = {0, 1, 0, -1};
+
+ public static void main(String[] args) throws IOException {
+ t = Integer.parseInt(br.readLine());
+
+ for (int i = 0; i < t; i++) {
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ m = Integer.parseInt(st.nextToken());
+ n = Integer.parseInt(st.nextToken());
+ k = Integer.parseInt(st.nextToken());
+
+ visited = new boolean[m][n];
+ map = new int[m][n];
+
+ for (int j = 0; j < k; j++) {
+ st = new StringTokenizer(br.readLine());
+ int a = Integer.parseInt(st.nextToken());
+ int b = Integer.parseInt(st.nextToken());
+ map[a][b] = 1;
+ }
+
+ int count = 0;
+ for (int j = 0; j < m; j++) {
+ for (int l = 0; l < n; l++) {
+ if (map[j][l] == 1 && !visited[j][l]) {
+ dfs(j, l);
+ count++;
+ }
+ }
+ }
+ sb.append(count).append("\n");
+ }
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+
+ static void dfs(int x, int y) {
+ visited[x][y] = true;
+
+ for (int i = 0; i < 4; i++) {
+ int nx = x + dx[i];
+ int ny = y + dy[i];
+ if (nx >= 0 && ny >= 0 && nx < m && ny < n) {
+ //배추가 아직 있고 방문하지 않은 경우에만
+ if (map[nx][ny] == 1 && !visited[nx][ny]) {
+ dfs(nx, ny);
+ }
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-11404] \355\224\214\353\241\234\354\235\264\353\223\234.java" "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-11404] \355\224\214\353\241\234\354\235\264\353\223\234.java"
new file mode 100644
index 0000000..9077ed9
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-11404] \355\224\214\353\241\234\354\235\264\353\223\234.java"
@@ -0,0 +1,62 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ // 빠른 입출력을 위한 BufferedReader와 BufferedWriter 사용
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ int n = Integer.parseInt(br.readLine()); // 정점의 개수
+ int m = Integer.parseInt(br.readLine()); // 간선의 개수
+
+ // INF: 경로가 없음을 나타내기 위한 값 (문제 조건에 따라 충분히 큰 값)
+ final int INF = 1000000000;
+ int[][] dist = new int[n + 1][n + 1];
+
+ // 1. 초기화: 모든 값을 INF로, 자기 자신으로 가는 거리는 0으로 설정
+ for (int i = 1; i <= n; i++) {
+ Arrays.fill(dist[i], INF);
+ dist[i][i] = 0;
+ }
+
+ // 2. 간선 정보 입력: a에서 b로 가는 비용 갱신 (최소값 선택)
+ for (int i = 0; i < m; i++) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int a = Integer.parseInt(st.nextToken());
+ int b = Integer.parseInt(st.nextToken());
+ int cost = Integer.parseInt(st.nextToken());
+ // 같은 간선이 여러 번 주어지는 경우를 대비하여 최소값 저장
+ dist[a][b] = Math.min(dist[a][b], cost);
+ }
+
+ // 3. 플로이드–워셜 알고리즘 수행
+ for (int k = 1; k <= n; k++) {
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= n; j++) {
+ if (dist[i][j] > dist[i][k] + dist[k][j]) {
+ dist[i][j] = dist[i][k] + dist[k][j];
+ }
+ }
+ }
+ }
+
+ // 4. 결과 출력: 경로가 없으면 0을 출력
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ StringBuilder sb = new StringBuilder();
+ for (int i = 1; i <= n; i++) {
+ for (int j = 1; j <= n; j++) {
+ sb.append((dist[i][j] == INF ? 0 : dist[i][j])).append(" ");
+ }
+ sb.append("\n");
+ }
+
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1260] DFS\354\231\200 BFS.java" "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1260] DFS\354\231\200 BFS.java"
new file mode 100644
index 0000000..f94ccce
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1260] DFS\354\231\200 BFS.java"
@@ -0,0 +1,102 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+/*
+1. 입력
+ 1-1 정점의 개수 n, 간선의 개수 m, 탐색을 시작할 정점의 번호 v
+ 1-2 m 번 간선이 연결하는 두 정점의 번호가 주어짐
+2. 로직
+ 2-1 첫줄에 dfs 수행한 결과
+ 2-2 둘째 줄에 bfs 수행한 결과
+ */
+
+public class Main {
+ static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+ static StringBuilder sb;
+
+ static boolean[] visited;
+ static int[] res;
+ static ArrayList[] tree;
+
+ static int n, m, v;
+
+ public static void main(String[] args) throws IOException {
+
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ n = Integer.parseInt(st.nextToken());
+ m = Integer.parseInt(st.nextToken());
+ v = Integer.parseInt(st.nextToken());
+
+ tree = new ArrayList[n + 1];
+
+ for (int i = 1; i <= n; i++) {
+ tree[i] = new ArrayList<>();
+ }
+
+ for (int i = 0; i < m; i++) {
+ st = new StringTokenizer(br.readLine());
+ int a = Integer.parseInt(st.nextToken());
+ int b = Integer.parseInt(st.nextToken());
+ tree[a].add(b);
+ tree[b].add(a);
+ }
+
+ for (int i = 1; i <= n; i++) {
+ Collections.sort(tree[i]);
+ }
+
+ sb = new StringBuilder("");
+ visited = new boolean[n + 1];
+ dfs(v);
+ bw.write(sb.toString() + "\n");
+
+ sb = new StringBuilder("");
+ bfs(v);
+ bw.write(sb.toString());
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+
+ static void dfs(int v) {
+
+ visited[v] = true;
+
+ sb.append(v).append(" ");
+
+ for (int next : tree[v]) {
+ if (!visited[next]) {
+ dfs(next);
+ }
+ }
+ }
+
+ static void bfs(int current) {
+ boolean[] visitedbfs = new boolean[n + 1];
+ Queue q = new ArrayDeque<>();
+
+ q.add(current);
+ visitedbfs[current] = true;
+ while (!q.isEmpty()) {
+ int cur = q.poll();
+ sb.append(cur).append(" ");
+
+ for (int next : tree[cur]) {
+ if (!visitedbfs[next]) {
+ visitedbfs[next] = true;
+ q.add(next);
+ }
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1697] \354\210\250\353\260\224\352\274\255\354\247\210.java" "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1697] \354\210\250\353\260\224\352\274\255\354\247\210.java"
new file mode 100644
index 0000000..72998f7
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/9\354\243\274\354\260\250/[Baekjoon-1697] \354\210\250\353\260\224\352\274\255\354\247\210.java"
@@ -0,0 +1,42 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.StringTokenizer;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ 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 MAX = 100000;
+
+ // 방문 및 거리 기록 배열, -1은 아직 방문하지 않음을 의미
+ int[] dist = new int[MAX + 1];
+ Arrays.fill(dist, -1);
+
+ Queue queue = new LinkedList<>();
+ queue.add(N);
+ dist[N] = 0;
+
+ while(!queue.isEmpty()){
+ int cur = queue.poll();
+ if(cur == K){
+ System.out.println(dist[cur]);
+ return;
+ }
+
+ // 가능한 이동: -1, +1, *2
+ int[] nextPositions = {cur - 1, cur + 1, cur * 2};
+ for (int next : nextPositions) {
+ if(next >= 0 && next <= MAX && dist[next] == -1){
+ dist[next] = dist[cur] + 1;
+ queue.add(next);
+ }
+ }
+ }
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/[Baekjoon-1181] \353\213\250\354\226\264\354\240\225\353\240\254.java" "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-1181] \353\213\250\354\226\264\354\240\225\353\240\254.java"
new file mode 100644
index 0000000..877b52f
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-1181] \353\213\250\354\226\264\354\240\225\353\240\254.java"
@@ -0,0 +1,48 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ int n = Integer.parseInt(br.readLine());
+
+ //문자열 배열
+ String[] input = new String[n];
+
+ //문자열 입력받기
+ for (int i = 0; i < n; i++) {
+ input[i] = br.readLine();
+ }
+
+ Arrays.sort(input, new Comparator() {
+
+ @Override
+ public int compare(String o1, String o2) {
+ //두 단어 길이가 다르면 길이 차이 반환
+ if (o1.length() != o2.length()) {
+ return o1.length() - o2.length();
+ }
+ //길이가 같다면 사전순
+ return o1.compareTo(o2);
+ }
+ });
+
+ for (int i = 0; i < n; i++) {
+ //정렬되어 있으므로 첫번쨰거나 연속되는 문자와 다를경우에만 출력
+ if (i == 0 || !input[i].equals(input[i - 1])) {
+ bw.write(input[i] + "\n");
+ }
+ }
+ bw.flush();
+ bw.close();
+ br.close();
+
+ }
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/[Baekjoon-1193] \353\266\204\354\210\230\354\260\276\352\270\260" "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-1193] \353\266\204\354\210\230\354\260\276\352\270\260"
new file mode 100644
index 0000000..691d0e0
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-1193] \353\266\204\354\210\230\354\260\276\352\270\260"
@@ -0,0 +1,43 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+public class Main {
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+
+ int x = Integer.parseInt(br.readLine());
+
+ // 대각선 찾기
+ int n = 0; // 대각선 번호
+ int sum = 0; // 대각선별 누적합
+ while(sum < x) {
+ n++; // 다음 대각선으로 넘어감
+ sum += n; // 현재 대각선의 분수 개수를 누적합에 더함
+ }
+
+ // 대각선 내 위치
+ // 이전 대각선까지의 누적합은 (sum - n)임
+ int offset = x - (sum - n); // 현재 대각선 안에서 몇 번째 분수인지
+
+ // 분자와 분모
+ int numerator, denominator;
+ if(n % 2 == 0) { // 짝수 대각선: 아래에서 위로 진행
+ numerator = offset;
+ denominator = n + 1 - offset;
+ } else { // 홀수 대각선: 위에서 아래로 진행
+ numerator = n + 1 - offset;
+ denominator = offset;
+ }
+
+
+ bw.write(numerator + "/" + denominator);
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
diff --git "a/\354\240\225\353\257\274\354\204\234/[Baekjoon-2563] \354\203\211\354\242\205\354\235\264.java" "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-2563] \354\203\211\354\242\205\354\235\264.java"
new file mode 100644
index 0000000..b728d4e
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-2563] \354\203\211\354\242\205\354\235\264.java"
@@ -0,0 +1,53 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ //가로 세로 크기 100인 도화지
+ public static boolean[][] blank = new boolean[100][100];
+
+ //총 면적
+ public static int count = 0;
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ //색종이의 갯수
+ int n = Integer.parseInt(br.readLine());
+
+ for (int paper = 0; paper < n; paper++) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+
+ //각 색종이의 좌표
+ int x = Integer.parseInt(st.nextToken());
+ int y = Integer.parseInt(st.nextToken());
+
+ //주어진 좌표부터 +10까지 배열 true 처리
+ for (int i = x; i < x + 10; i++) {
+ for (int j = y; j < y + 10; j++) {
+ blank[i][j] = true;
+ }
+ }
+ }
+
+ for (int i = 0; i < 100; i++) {
+ for (int j = 0; j < 100; j++) {
+ if (blank[i][j]) {
+ count++;
+ }
+ }
+ }
+
+ bw.write(String.valueOf(count));
+ bw.flush();
+ bw.close();
+ br.close();
+
+
+ }
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/[Baekjoon-3711] \355\225\231\353\262\210.java" "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-3711] \355\225\231\353\262\210.java"
new file mode 100644
index 0000000..87f419f
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-3711] \355\225\231\353\262\210.java"
@@ -0,0 +1,66 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.HashSet;
+
+public class Main {
+
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ //테스트 케이스
+ int test = Integer.parseInt(br.readLine());
+
+ for (int caseN = 0; caseN < test; caseN++) {
+
+ //가장 작은 양의 정수
+ int m = 1;
+
+ // 학생 수
+ int g = Integer.parseInt(br.readLine());
+
+ //학번 배열 입력받기
+ int[] studentNum = new int[g];
+ for (int student = 0; student < g; student++) {
+ studentNum[student] = Integer.parseInt(br.readLine());
+ }
+
+ //나머지 배열에서 set 사용해서 중복검증
+ HashSet leftover = new HashSet<>();
+
+ while (true) {
+
+ boolean valid = true;
+
+ //배열을 새로 할당하지 않고 재사용해 메모리 사용량 줄이기
+ leftover.clear();
+
+ for (int i = 0; i < g; i++) {
+ int temp = studentNum[i] % m;
+ if (leftover.contains(temp)) {
+ valid = false;
+ break;
+ } else {
+ leftover.add(temp);
+ }
+ }
+ //중복이 없다면 반복문 종료
+ if (valid) {
+ break;
+ } else {
+ m++;
+ }
+
+ }
+ bw.write(String.valueOf(m) + "\n");
+ }
+
+ bw.flush();
+ bw.close();
+ br.close();
+ }
+}
\ No newline at end of file
diff --git "a/\354\240\225\353\257\274\354\204\234/[Baekjoon-4108] \354\247\200\353\242\260\354\260\276\352\270\260.java" "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-4108] \354\247\200\353\242\260\354\260\276\352\270\260.java"
new file mode 100644
index 0000000..d62ac9d
--- /dev/null
+++ "b/\354\240\225\353\257\274\354\204\234/[Baekjoon-4108] \354\247\200\353\242\260\354\260\276\352\270\260.java"
@@ -0,0 +1,82 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.StringTokenizer;
+
+public class Main {
+
+ //상하좌우 대각선 방향 포함
+ public static int[] dx = {0, 1, 1, 1, 0, -1, -1, -1};
+ public static int[] dy = {1, 1, 0, -1, -1, -1, 0, 1};
+
+ public static void main(String[] args) throws IOException {
+ BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+ while (true) {
+ StringTokenizer st = new StringTokenizer(br.readLine());
+ int r = Integer.parseInt(st.nextToken());
+ int c = Integer.parseInt(st.nextToken());
+
+ //종료조건
+ if (r == 0 && c == 0) {
+ break;
+ }
+
+ //지뢰 위치 입력받기
+ char[][] map = new char[r][c];
+ for (int i = 0; i < r; i++) {
+ String line = br.readLine();
+ for (int j = 0; j < c; j++) {
+ map[i][j] = line.charAt(j);
+ }
+ }
+
+ //결과 배열
+ char[][] result = new char[r][c];
+
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ if (map[i][j] == '.') {
+
+ int count = 0;
+ for (int k = 0; k < dx.length; k++) {
+ int newX = i + dx[k];
+ int newY = j + dy[k];
+
+ if (inRange(newX, newY, r, c)) {
+ if (map[newX][newY] == '*') {
+ count++;
+ }
+ }
+ }
+ char digit = (char) ('0' + count);
+ result[i][j] = digit;
+ } else {
+ result[i][j] = map[i][j];
+ }
+ }
+ }
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ bw.write(result[i][j]);
+ }
+ bw.newLine();
+ }
+ }
+ bw.flush();
+ bw.close();
+ br.close();
+
+
+ }
+
+ public static boolean inRange(int x, int y, int r, int c) {
+ if (x >= 0 && y >= 0 && x < r && y < c) {
+ return true;
+ }
+ return false;
+ }
+}
\ No newline at end of file