From d83ba98b19ccde018a3a17afdef354047a8be005 Mon Sep 17 00:00:00 2001
From: busker <165013324+hiroki-horiguchi-dev@users.noreply.github.com>
Date: Fri, 5 Jun 2026 19:16:48 +0900
Subject: [PATCH] solve 112

---
 tree-bst/112.md | 131 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 131 insertions(+)

diff --git a/tree-bst/112.md b/tree-bst/112.md
index e69de29..8102698 100644
--- a/tree-bst/112.md
+++ b/tree-bst/112.md
@@ -0,0 +1,131 @@
+- [112. Path Sum](https://leetcode.com/problems/path-sum/description/)
+- 方針
+  - コールスタック対策を考えると、BFS が適切だと思った
+  - が、別に再起でやってもQueueでやっても結局全探索なので時間計算量的には最悪O(N)で変わらない
+  - 再帰のコールスタックは今回の最悪データ量 5000 に耐えられない可能性があるので、再帰関数は採用しない
+- Queueの場合
+  - 実装時間: 10分
+  - 時間計算量: O(N), 空間計算量: O(N)
+- Stackの場合
+  - 実装時間: 5分 Queue とやっていることは全く同じ
+  - 時間計算量、空間計算量ともに Queue の場合と同じ
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        if (root == null) {
+            return false;
+        }
+
+        Deque<NodeAndPrefixSum> nodes = new ArrayDeque<>();
+        nodes.addLast(new NodeAndPrefixSum(root, root.val));
+
+        while (!nodes.isEmpty()) {
+            NodeAndPrefixSum node = nodes.pollFirst();
+
+            if (node.treeNode.left != null) {
+                nodes.addLast(
+                        new NodeAndPrefixSum(
+                                node.treeNode.left,
+                                node.prefixSum + node.treeNode.left.val
+                        )
+                );
+            }
+
+            if (node.treeNode.right != null) {
+                nodes.addLast(
+                        new NodeAndPrefixSum(
+                                node.treeNode.right,
+                                node.prefixSum + node.treeNode.right.val
+                        )
+                );
+            }
+
+            if (node.treeNode.left == null
+                    && node.treeNode.right == null
+                    && node.prefixSum == targetSum) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private record NodeAndPrefixSum(TreeNode treeNode, int prefixSum) {}
+}
+```
+
+
+- Stack
+
+```java
+import java.util.ArrayDeque;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+  public boolean hasPathSum(TreeNode root, int targetSum) {
+    if (root == null) {
+      return false;
+    }
+
+    Deque<NodeAndPrefixSum> nodes = new ArrayDeque<>();
+    nodes.addLast(new NodeAndPrefixSum(root, root.val));
+    while (!nodes.isEmpty()) {
+      NodeAndPrefixSum node = nodes.pollLast();
+
+      if (node.treeNode.left != null) {
+        nodes.addLast(new NodeAndPrefixSum(
+                node.treeNode.left,
+                node.prefixSum + node.treeNode.left.val
+        ));
+      }
+
+      if (node.treeNode.right != null) {
+        nodes.addLast(new NodeAndPrefixSum(
+                node.treeNode.right,
+                node.prefixSum + node.treeNode.right.val
+        ));
+      }
+
+      if (node.treeNode.left == null
+              && node.treeNode.right == null
+              && node.prefixSum == targetSum) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private record NodeAndPrefixSum(TreeNode treeNode, int prefixSum) {}
+}
+```
+