From fcacb2861677894c5de636af7114ff94bd1b914e Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Thu, 19 Mar 2026 13:43:58 +0900
Subject: [PATCH 1/6] step1

---
 memo.md              | 93 ++++++++++++++++++++++++++++++++++++++++++++
 step1-1_recursion.py | 14 +++++++
 step1-2_dfs.py       | 24 ++++++++++++
 step1-3_bfs.py       | 27 +++++++++++++
 4 files changed, 158 insertions(+)
 create mode 100644 step1-1_recursion.py
 create mode 100644 step1-2_dfs.py
 create mode 100644 step1-3_bfs.py

diff --git a/memo.md b/memo.md
index 4bd0397..69ee0c6 100644
--- a/memo.md
+++ b/memo.md
@@ -1 +1,94 @@
 # Step1
+
+## アプローチ
+
+* 今まで見た値と自分が見るべきノードを渡される
+* 自分が見るノードが葉だったら, 足したものがtargetになるかかくにん
+* そうじゃなかったら足したものと次見るノードを引き継ぐ
+* 関数による再帰呼び出しでも, stackを使ったDFSでもいけそう
+* BFSでもできそう
+* 関数呼び出しの木の深さ分行われるから, 最悪の場合で5000
+
+## Code1-1 (Recursion)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        if root.left is None and root.right is None:
+            return root.val == targetSum
+        next_targetSum = targetSum - root.val
+        return self.hasPathSum(root.left, next_targetSum) or self.hasPathSum(root.right, next_targetSum)
+
+```
+
+## Code1-2 (DFS)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        frontier = [(root, targetSum)]
+        while frontier:
+            node, target = frontier.pop()
+            if node.left is None and node.right is None:
+                if node.val == target:
+                    return True
+                continue
+            if node.left is not None:
+                frontier.append((node.left, target - node.val))
+            if node.right is not None:
+                frontier.append((node.right, target - node.val))
+        return False
+
+        
+
+```
+
+## Code1-3 (BFS)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        
+        frontier = [(root, targetSum)]
+        while frontier:
+            next_frontier = []
+            while frontier:
+                node, target = frontier.pop()
+                if node.left is None and node.right is None:
+                    if node.val == target:
+                        return True
+                    continue
+                if node.left is not None:
+                    next_frontier.append((node.left, target - node.val))
+                if node.right is not None:
+                    next_frontier.append((node.right, target - node.val))
+            frontier = next_frontier
+        
+        return False
+
+
+```
\ No newline at end of file
diff --git a/step1-1_recursion.py b/step1-1_recursion.py
new file mode 100644
index 0000000..ce2ef61
--- /dev/null
+++ b/step1-1_recursion.py
@@ -0,0 +1,14 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        if root.left is None and root.right is None:
+            return root.val == targetSum
+        next_targetSum = targetSum - root.val
+        return self.hasPathSum(root.left, next_targetSum) or self.hasPathSum(root.right, next_targetSum)
\ No newline at end of file
diff --git a/step1-2_dfs.py b/step1-2_dfs.py
new file mode 100644
index 0000000..6107b95
--- /dev/null
+++ b/step1-2_dfs.py
@@ -0,0 +1,24 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        frontier = [(root, targetSum)]
+        while frontier:
+            node, target = frontier.pop()
+            if node.left is None and node.right is None:
+                if node.val == target:
+                    return True
+                continue
+            if node.left is not None:
+                frontier.append((node.left, target - node.val))
+            if node.right is not None:
+                frontier.append((node.right, target - node.val))
+        return False
+
+        
\ No newline at end of file
diff --git a/step1-3_bfs.py b/step1-3_bfs.py
new file mode 100644
index 0000000..f698935
--- /dev/null
+++ b/step1-3_bfs.py
@@ -0,0 +1,27 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        
+        frontier = [(root, targetSum)]
+        while frontier:
+            next_frontier = []
+            while frontier:
+                node, target = frontier.pop()
+                if node.left is None and node.right is None:
+                    if node.val == target:
+                        return True
+                    continue
+                if node.left is not None:
+                    next_frontier.append((node.left, target - node.val))
+                if node.right is not None:
+                    next_frontier.append((node.right, target - node.val))
+            frontier = next_frontier
+        
+        return False

From 1fe1e458fc1967504e605d2b9eb6c62a1a7ac91e Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Tue, 24 Mar 2026 04:19:31 +0900
Subject: [PATCH 2/6] step2

---
 memo.md              | 82 ++++++++++++++++++++++++++++++++++++++++++++
 step2-1_recursion.py | 15 ++++++++
 step2-2_dfs.py       | 23 +++++++++++++
 step2-3_bfs.py       | 26 ++++++++++++++
 4 files changed, 146 insertions(+)
 create mode 100644 step2-1_recursion.py
 create mode 100644 step2-2_dfs.py
 create mode 100644 step2-3_bfs.py

diff --git a/memo.md b/memo.md
index 69ee0c6..f33e010 100644
--- a/memo.md
+++ b/memo.md
@@ -91,4 +91,86 @@ class Solution:
         return False
 
 
+```
+
+# Step2
+
+## Code2-1 (Recursion)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        is_leaf = root.left is None and root.right is None
+        if is_leaf and root.val == targetSum:
+            return True
+        next_targetSum = targetSum - root.val
+        return self.hasPathSum(root.left, next_targetSum) or self.hasPathSum(root.right, next_targetSum)
+
+```
+
+## Code2-2 (DFS)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        node_to_visit = [(root, 0)]
+        while node_to_visit:
+            node, pathsum_before_this_node = node_to_visit.pop()
+            is_leaf = node.left is None and node.right is None
+            if is_leaf and pathsum_before_this_node + node.val == targetSum:
+                return True
+            if node.left is not None:
+                node_to_visit.append((node.left, pathsum_before_this_node + node.val))
+            if node.right is not None:
+                node_to_visit.append((node.right, pathsum_before_this_node + node.val))
+        return False
+
+``` 
+
+## Code2-3 (BFS)
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        
+        frontier = [(root, 0)]
+        while frontier:
+            next_frontier = []
+            while frontier:
+                node, pathsum_before_this_node = frontier.pop()
+                is_leaf = node.left is None and node.right is None
+                if is_leaf and pathsum_before_this_node + node.val == targetSum:
+                    return True
+                if node.left is not None:
+                    next_frontier.append((node.left, pathsum_before_this_node + node.val))
+                if node.right is not None:
+                    next_frontier.append((node.right, pathsum_before_this_node + node.val))
+            frontier = next_frontier
+        
+        return False
+
 ```
\ No newline at end of file
diff --git a/step2-1_recursion.py b/step2-1_recursion.py
new file mode 100644
index 0000000..425728c
--- /dev/null
+++ b/step2-1_recursion.py
@@ -0,0 +1,15 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        is_leaf = root.left is None and root.right is None
+        if is_leaf and root.val == targetSum:
+            return True
+        next_targetSum = targetSum - root.val
+        return self.hasPathSum(root.left, next_targetSum) or self.hasPathSum(root.right, next_targetSum)
\ No newline at end of file
diff --git a/step2-2_dfs.py b/step2-2_dfs.py
new file mode 100644
index 0000000..b42e61f
--- /dev/null
+++ b/step2-2_dfs.py
@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        node_to_visit = [(root, 0)]
+        while node_to_visit:
+            node, pathsum_before_this_node = node_to_visit.pop()
+            is_leaf = node.left is None and node.right is None
+            if is_leaf and pathsum_before_this_node + node.val == targetSum:
+                return True
+            if node.left is not None:
+                node_to_visit.append((node.left, pathsum_before_this_node + node.val))
+            if node.right is not None:
+                node_to_visit.append((node.right, pathsum_before_this_node + node.val))
+        return False
+
+        
\ No newline at end of file
diff --git a/step2-3_bfs.py b/step2-3_bfs.py
new file mode 100644
index 0000000..7dd97b5
--- /dev/null
+++ b/step2-3_bfs.py
@@ -0,0 +1,26 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        
+        frontier = [(root, 0)]
+        while frontier:
+            next_frontier = []
+            while frontier:
+                node, pathsum_before_this_node = frontier.pop()
+                is_leaf = node.left is None and node.right is None
+                if is_leaf and pathsum_before_this_node + node.val == targetSum:
+                    return True
+                if node.left is not None:
+                    next_frontier.append((node.left, pathsum_before_this_node + node.val))
+                if node.right is not None:
+                    next_frontier.append((node.right, pathsum_before_this_node + node.val))
+            frontier = next_frontier
+        
+        return False

From ba33f9d7955d7ce505039e0f16f7c6aeef709b40 Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Tue, 24 Mar 2026 04:30:16 +0900
Subject: [PATCH 3/6] step3 1st

---
 step3-1_recursion.py | 20 ++++++++++++++++++++
 step3-2_dfs.py       | 25 +++++++++++++++++++++++++
 step3-3_bfs.py       | 28 ++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 step3-1_recursion.py
 create mode 100644 step3-2_dfs.py
 create mode 100644 step3-3_bfs.py

diff --git a/step3-1_recursion.py b/step3-1_recursion.py
new file mode 100644
index 0000000..497d1b0
--- /dev/null
+++ b/step3-1_recursion.py
@@ -0,0 +1,20 @@
+# 1st: 2:24
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        is_leaf = root.left is None and root.right is None
+        if is_leaf and root.val == targetSum:
+            return True
+        next_target_sum = targetSum - root.val
+        return self.hasPathSum(root.left, next_target_sum) or self.hasPathSum(root.right, next_target_sum)
+
+        
\ No newline at end of file
diff --git a/step3-2_dfs.py b/step3-2_dfs.py
new file mode 100644
index 0000000..dec14bf
--- /dev/null
+++ b/step3-2_dfs.py
@@ -0,0 +1,25 @@
+# 1st: 3:27
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        node_to_visit = [(root, targetSum)]
+        while node_to_visit:
+            node, target_sum_at_this_node = node_to_visit.pop()
+            is_leaf = node.left is None and node.right is None
+            if is_leaf and node.val == target_sum_at_this_node:
+                return True
+            if node.left is not None:
+                node_to_visit.append((node.left, target_sum_at_this_node - node.val))
+            if node.right is not None:
+                node_to_visit.append((node.right, target_sum_at_this_node - node.val))
+        return False
+        
diff --git a/step3-3_bfs.py b/step3-3_bfs.py
new file mode 100644
index 0000000..86a4d12
--- /dev/null
+++ b/step3-3_bfs.py
@@ -0,0 +1,28 @@
+# 1st: 1:54
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        
+        frontier = [(root, targetSum)]
+        while frontier:
+            next_level_frontier = []
+            while frontier:
+                node, target_sum_at_this_node = frontier.pop()
+                is_leaf = node.left is None and node.right is None
+                if is_leaf and node.val == target_sum_at_this_node:
+                    return True
+                if node.left is not None:
+                    next_level_frontier.append((node.left, target_sum_at_this_node - node.val))
+                if node.right is not None:
+                    next_level_frontier.append((node.right, target_sum_at_this_node - node.val))
+            frontier = next_level_frontier
+        return False
\ No newline at end of file

From 4eac42bcff599257ac761d960c2d1882af89a1cd Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Tue, 24 Mar 2026 04:34:59 +0900
Subject: [PATCH 4/6] step3 2nd

---
 step3-1_recursion.py | 6 ++----
 step3-2_dfs.py       | 4 ++--
 step3-3_bfs.py       | 2 +-
 3 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/step3-1_recursion.py b/step3-1_recursion.py
index 497d1b0..bf8b95e 100644
--- a/step3-1_recursion.py
+++ b/step3-1_recursion.py
@@ -1,4 +1,5 @@
 # 1st: 2:24
+# 2nd: 0:51
 
 
 # Definition for a binary tree node.
@@ -14,7 +15,4 @@ def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
         is_leaf = root.left is None and root.right is None
         if is_leaf and root.val == targetSum:
             return True
-        next_target_sum = targetSum - root.val
-        return self.hasPathSum(root.left, next_target_sum) or self.hasPathSum(root.right, next_target_sum)
-
-        
\ No newline at end of file
+        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)
diff --git a/step3-2_dfs.py b/step3-2_dfs.py
index dec14bf..96e5f71 100644
--- a/step3-2_dfs.py
+++ b/step3-2_dfs.py
@@ -1,4 +1,5 @@
 # 1st: 3:27
+# 2nd: 1:13
 
 
 # Definition for a binary tree node.
@@ -21,5 +22,4 @@ def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
                 node_to_visit.append((node.left, target_sum_at_this_node - node.val))
             if node.right is not None:
                 node_to_visit.append((node.right, target_sum_at_this_node - node.val))
-        return False
-        
+        return False
\ No newline at end of file
diff --git a/step3-3_bfs.py b/step3-3_bfs.py
index 86a4d12..c8e453e 100644
--- a/step3-3_bfs.py
+++ b/step3-3_bfs.py
@@ -1,4 +1,5 @@
 # 1st: 1:54
+# 2nd: 1:39
 
 
 # Definition for a binary tree node.
@@ -11,7 +12,6 @@ class Solution:
     def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
         if root is None:
             return False
-        
         frontier = [(root, targetSum)]
         while frontier:
             next_level_frontier = []

From 1483eb8aea877d407902d7cde7363629707311e1 Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Tue, 24 Mar 2026 04:39:48 +0900
Subject: [PATCH 5/6] step3 3rd

---
 step3-1_recursion.py | 3 ++-
 step3-2_dfs.py       | 1 +
 step3-3_bfs.py       | 1 +
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/step3-1_recursion.py b/step3-1_recursion.py
index bf8b95e..afb194b 100644
--- a/step3-1_recursion.py
+++ b/step3-1_recursion.py
@@ -1,5 +1,6 @@
 # 1st: 2:24
 # 2nd: 0:51
+# 3rd: 0:53
 
 
 # Definition for a binary tree node.
@@ -15,4 +16,4 @@ def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
         is_leaf = root.left is None and root.right is None
         if is_leaf and root.val == targetSum:
             return True
-        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)
+        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)
\ No newline at end of file
diff --git a/step3-2_dfs.py b/step3-2_dfs.py
index 96e5f71..9cb7367 100644
--- a/step3-2_dfs.py
+++ b/step3-2_dfs.py
@@ -1,5 +1,6 @@
 # 1st: 3:27
 # 2nd: 1:13
+# 3rd: 1:17
 
 
 # Definition for a binary tree node.
diff --git a/step3-3_bfs.py b/step3-3_bfs.py
index c8e453e..6dd8271 100644
--- a/step3-3_bfs.py
+++ b/step3-3_bfs.py
@@ -1,5 +1,6 @@
 # 1st: 1:54
 # 2nd: 1:39
+# 3rd: 1:26
 
 
 # Definition for a binary tree node.

From c152922a0793b44ce333eb04633e5f1f12ca3041 Mon Sep 17 00:00:00 2001
From: Kazuki Kitano <kitano-kazuki954@g.ecc.u-tokyo.ac.jp>
Date: Tue, 24 Mar 2026 04:41:04 +0900
Subject: [PATCH 6/6] step3 memo

---
 memo.md | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)

diff --git a/memo.md b/memo.md
index f33e010..2084c31 100644
--- a/memo.md
+++ b/memo.md
@@ -173,4 +173,95 @@ class Solution:
         
         return False
 
+```
+
+# Step3
+
+## Code3-1 (Recursion)
+
+```python
+# 1st: 2:24
+# 2nd: 0:51
+# 3rd: 0:53
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        is_leaf = root.left is None and root.right is None
+        if is_leaf and root.val == targetSum:
+            return True
+        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)
+```
+
+## Code3-2 (DFS)
+
+```python
+# 1st: 3:27
+# 2nd: 1:13
+# 3rd: 1:17
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        node_to_visit = [(root, targetSum)]
+        while node_to_visit:
+            node, target_sum_at_this_node = node_to_visit.pop()
+            is_leaf = node.left is None and node.right is None
+            if is_leaf and node.val == target_sum_at_this_node:
+                return True
+            if node.left is not None:
+                node_to_visit.append((node.left, target_sum_at_this_node - node.val))
+            if node.right is not None:
+                node_to_visit.append((node.right, target_sum_at_this_node - node.val))
+        return False
+```
+
+## Code3-3 (BFS)
+
+```python
+# 1st: 1:54
+# 2nd: 1:39
+# 3rd: 1:26
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def hasPathSum(self, root: TreeNode | None, targetSum: int) -> bool:
+        if root is None:
+            return False
+        frontier = [(root, targetSum)]
+        while frontier:
+            next_level_frontier = []
+            while frontier:
+                node, target_sum_at_this_node = frontier.pop()
+                is_leaf = node.left is None and node.right is None
+                if is_leaf and node.val == target_sum_at_this_node:
+                    return True
+                if node.left is not None:
+                    next_level_frontier.append((node.left, target_sum_at_this_node - node.val))
+                if node.right is not None:
+                    next_level_frontier.append((node.right, target_sum_at_this_node - node.val))
+            frontier = next_level_frontier
+        return False
 ```
\ No newline at end of file