在给定预算内可以访问的最大叶节点数

对于一个二叉树，假设每个节点的费用为1，现在有一个预算B，问你在这个预算内可以访问的最大叶节点数是多少？

例如，如下图所示的一棵树：

        1
       / \
      2   3
     /   / \
    4   5   6

假设预算B为4，则最多能访问到的叶节点数为3，对应的路径为1-2-4、1-3-5、1-3-6。

解决这个问题的核心思路是贪心算法，我们可以考虑在每个节点处，其左右儿子并不一定都需要遍历，只要其中一个儿子可以访问到足够多的叶节点，另一个儿子则可以被舍弃，从而有效地降低花费。

具体来说，我们可以定义一个函数 dfs(node) 表示以 node 为根的子树中，花费为 B 时能访问到的最大叶节点数。我们可以从叶子节点开始递归，设叶节点的 dfs 值为 1，然后对于每个非叶子节点，我们计算其左右子树的 dfs 值，然后根据这两个值和左右子树的节点数量来计算以该节点为根的子树的 dfs 值。具体算法如下：

def dfs(node):
    if not node.left and not node.right:
        return 1
    if not node.left and node.cost <= b:
        return 1
    if not node.right and node.cost <= b:
        return 1
    cost1 = dfs(node.left) + (node.cost if node.left else 0)
    cost2 = dfs(node.right) + (node.cost if node.right else 0)
    count1 = count_leaves(node.left) if node.left else 0
    count2 = count_leaves(node.right) if node.right else 0
    total_count = count1 + count2
    if cost1 <= b and cost2 <= b:
        return max(count1, count2)
    if cost1 <= b and cost2 > b:
        return count1
    if cost1 > b and cost2 <= b:
        return count2
    if cost1 > b and cost2 > b:
        if total_count < 2:
            return 0
        else:
            return dfs(node.left) + dfs(node.right)

其中，count_leaves(node) 表示以 node 为根的子树中叶子节点的数量。

算法的时间复杂度为 O(n)，其中 n 为树上节点的数量，因为每个节点只会遍历一次。空间复杂度为 O(h)，其中 h 为树的高度，因为递归需要栈空间的支持。

我们可以通过如下简单的 Python 代码来测试该算法：

class Node:
    def __init__(self, cost, left=None, right=None):
        self.cost = cost
        self.left = left
        self.right = right
        
def count_leaves(node):
    if not node:
        return 0
    if not node.left and not node.right:
        return 1
    return count_leaves(node.left) + count_leaves(node.right)
    
def dfs(node):
    if not node.left and not node.right:
        return 1
    if not node.left and node.cost <= b:
        return 1
    if not node.right and node.cost <= b:
        return 1
    cost1 = dfs(node.left) + (node.cost if node.left else 0)
    cost2 = dfs(node.right) + (node.cost if node.right else 0)
    count1 = count_leaves(node.left) if node.left else 0
    count2 = count_leaves(node.right) if node.right else 0
    total_count = count1 + count2
    if cost1 <= b and cost2 <= b:
        return max(count1, count2)
    if cost1 <= b and cost2 > b:
        return count1
    if cost1 > b and cost2 <= b:
        return count2
    if cost1 > b and cost2 > b:
        if total_count < 2:
            return 0
        else:
            return dfs(node.left) + dfs(node.right)
            
# 构造测试用例
root = Node(1,
    left=Node(2,
        left=Node(4),
        # right=Node(5),  # 这行代码控制访问 5 节点
    ),
    right=Node(3,
        left=Node(5),
        right=Node(6),
    ),
)
b = 4
print(dfs(root))

代码输出为：

3

表示在预算为 4 的情况下可以访问到 3 个叶节点。