fix: child node for NOT operation can be either side (minimum-flips-in-binary-tree-to-get-result)

problems/minimum_flips_in_binary_tree_to_get_result/minimum_flips_in_binary_tree_to_get_result.cc

@@ -30,7 +30,13 @@ int minimumFlips(TreeNode* root, bool result) {
             return {min({left_false + right_false, left_true + right_true}),
                     min({left_true + right_false, left_false + right_true})};
         } else if (x == 5) {  // NOT
-            return {left_true, left_false};
+            if (node->left && !node->right) {
+                return {left_true, left_false};
+            } else if (!node->left && node->right) {
+                return {right_true, right_false};
+            } else {
+                return {1 << 30, 1 << 30};  // Invalid operation
+            }
         } else {
             return {1 << 30, 1 << 30};  // Invalid operation
         }

problems/minimum_flips_in_binary_tree_to_get_result/minimum_flips_in_binary_tree_to_get_result.py

@@ -39,7 +39,12 @@ def dfs(node: Optional[TreeNode]) -> Tuple[int, int]:
                 min(left_false + right_true, left_true + right_false),
             )
         elif x == 5:  # NOT
-            return (left_true, left_false)
+            if node.left and not node.right:
+                return left_true, left_false
+            elif not node.left and node.right:
+                return right_true, right_false
+            else:
+                return inf, inf  # Invalid operation
         else:
             raise ValueError(f"Unknown operation: {x}")
 

problems/minimum_flips_in_binary_tree_to_get_result/minimum_flips_in_binary_tree_to_get_result_test.cc

@@ -95,5 +95,13 @@ INSTANTIATE_TEST_SUITE_P(
         MinimumFlipsCase{.test_name = "NotGateFlipToFalse",
                          .root = new TreeNode(5, new TreeNode(0), nullptr),
                          .result = false,
-                         .expected = 1}),
+                         .expected = 1},
+        MinimumFlipsCase{
+            .test_name = "ComplexXorTreeWithNotRightChild",
+            .root = new TreeNode(
+                4, new TreeNode(0),
+                new TreeNode(2, new TreeNode(0),
+                             new TreeNode(5, nullptr, new TreeNode(5, nullptr, new TreeNode(1))))),
+            .result = true,
+            .expected = 0}),
     [](const ::testing::TestParamInfo<MinimumFlipsCase> &info) { return info.param.test_name; });

problems/minimum_flips_in_binary_tree_to_get_result/minimum_flips_in_binary_tree_to_get_result_test.py

@@ -62,6 +62,17 @@
             False,
             1,
         ),  # Complex tree: XOR(OR(1,1), AND(1,0)) = 1, flip one child to make it 0
+        (
+            TreeNode(
+                4,
+                TreeNode(0),
+                TreeNode(
+                    2, TreeNode(0), TreeNode(5, None, TreeNode(5, None, TreeNode(1)))
+                ),
+            ),
+            True,
+            0,
+        ),  # Complex tree: XOR(0, OR(0, NOT(NOT(1)))) = 1, already true
     ],
     ids=[
         "leaf_0_to_true",
@@ -78,6 +89,7 @@
         "complex_tree_and_already_false",
         "complex_tree_xor_need_flip",
         "complex_tree_xor_to_false",
+        "complex_xor_tree_with_not_right_child",
     ],
 )
 def test_minimum_flips(root, result, expected):