diff --git "a/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250415 DFSBFS \353\213\250\354\226\264 \353\263\200\355\231\230.md" "b/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250415 DFSBFS \353\213\250\354\226\264 \353\263\200\355\231\230.md"
new file mode 100644
index 0000000..3b6efcb
--- /dev/null
+++ "b/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250415 DFSBFS \353\213\250\354\226\264 \353\263\200\355\231\230.md"	
@@ -0,0 +1,94 @@
+### 문제 링크
+[단어 변환](https://school.programmers.co.kr/learn/courses/30/lessons/43163)
+
+### 풀이 방법
+- BFS를 이용해 최소 변환 횟수를 계산한다.
+- 단어(word)와 변환 횟수(conversionCount)를 필드로 가지는 노드(Node) 클래스를 정의한다.
+- 방문한 적이 없고 현재 노드의 단어에서 변환 가능한 단어를 필드로 가지는 노드를 방문한다.
+
+### 소스 코드
+```java
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+class Node {
+    private final String word; // 단어
+    private final int conversionCount; // 변환 횟수
+    
+    Node(String word, int conversionCount) {
+        this.word = word;
+        this.conversionCount = conversionCount;
+    }
+    
+    public String getWord() {
+        return word;
+    }
+    
+    public int getConversionCount() {
+        return conversionCount;
+    }
+}
+
+class Solution {
+    private boolean[] visited; // 단어 방문 여부
+    private final Queue<Node> queue = new LinkedList<>();
+    
+    public int solution(String begin, String target, String[] words) {
+        int answer = 0;
+        
+        // target이 words에 포함되지 않는다면 begin을 target으로 변환 불가 -> 0 반환
+        if (!Arrays.asList(words).contains(target)) {
+            return answer;
+        }
+        
+        // 방문 여부 배열 초기화
+        visited = new boolean[words.length];
+        
+        // bfs를 이용한 최소 변환 횟수 계산
+        return bfs(begin, target, words);
+    }
+    
+    // 최소 변환 횟수 계산을 위한 너비 우선 탐색
+    private int bfs(String begin, String target, String[] words) {
+        queue.add(new Node(begin, 0)); // 시작 노드 추가
+        
+        while (!queue.isEmpty()) {
+            Node current = queue.poll();
+            
+            if (current.getWord().equals(target)) { // target으로 변환 완료
+                return current.getConversionCount(); // 변환 횟수 반환
+            }
+            
+            for (int i = 0; i < words.length; i++) {
+                String nextWord = words[i];
+                
+                // 방문한 적이 없고 현재 단어에서 변환 가능한 단어를 갖는 노드 방문
+                if (!visited[i] && canConvert(current.getWord(), nextWord)) {
+                    queue.add(new Node(nextWord, current.getConversionCount() + 1));
+                    visited[i] = true; // 방문 처리
+                }
+            }
+        }
+        
+        return 0; // 이 시점에는 변환 불가 -> 0 반환
+    }
+    
+    // currentWord를 nextWord로 변환할 수 있는지 확인
+    private boolean canConvert(String currentWord, String nextWord) {
+        int differentAlphabetCount = 0; // 서로 다른 알파벳 개수
+        
+        for (int i = 0; i < currentWord.length(); i++) {
+            if (differentAlphabetCount >= 2) { // 2개 이상 다르다면 변환 불가 -> false 반환
+                return false;
+            }
+            
+            if (currentWord.charAt(i) != nextWord.charAt(i)) {
+                differentAlphabetCount++;
+            }
+        }
+        
+        return differentAlphabetCount == 1;
+    }
+}
+```
\ No newline at end of file
diff --git "a/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250416 DFSBFS \355\203\200\352\262\237 \353\204\230\353\262\204.md" "b/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250416 DFSBFS \355\203\200\352\262\237 \353\204\230\353\262\204.md"
new file mode 100644
index 0000000..2d79eb3
--- /dev/null
+++ "b/\352\271\200\354\247\200\354\210\230/13\354\243\274\354\260\250/250416 DFSBFS \355\203\200\352\262\237 \353\204\230\353\262\204.md"	
@@ -0,0 +1,34 @@
+### 문제 링크
+[타겟 넘버](https://school.programmers.co.kr/learn/courses/30/lessons/43165)
+
+### 풀이 방법
+- 각 숫자에 대해 덧셈 또는 뺄셈의 두 가지 조합이 존재한다.
+- DFS를 이용해 모든 조합을 탐색하며 누적합을 계산한다.
+- numbers 배열의 끝에 도달했을 때 누적합이 target이면 경우의 수에 포함한다.
+- 최종적으로 가능한 모든 경우의 수를 합산하여 반환한다.
+
+### 소스 코드
+```java
+class Solution {
+    public int solution(int[] numbers, int target) {
+        return dfs(numbers, target, 0, 0);
+    }
+
+    // 백트래킹을 이용해 target을 만드는 경우의 수를 계산
+    private int dfs(int[] numbers, int target, int result, int index) {
+
+        // 모든 숫자를 다 사용한 경우
+        if (index == numbers.length) {
+
+            // 누적 결과가 target과 같으면 1(경우의 수에 포함) 아니면 0
+            return result == target ? 1 : 0;
+        }
+
+        // 현재 숫자를 더하거나 뺐을 때의 경우의 수를 각각 재귀 호출로 탐색
+        int wayCount = dfs(numbers, target, result + numbers[index], index + 1);
+        wayCount += dfs(numbers, target, result - numbers[index], index + 1);
+
+        return wayCount;
+    }
+}
+```
\ No newline at end of file