Counting the Only Child in the Binary Tree using Breadth First Search Algorithm

/**
 * class Tree {
 *     public:
 *         int val;
 *         Tree *left;
 *         Tree *right;
 * };
 */
int countOnlyChildInBinaryTree(Tree* root) {
    if (!root) return 0;
    queue<pair<Tree*, int>> Q;
    Q.emplace(root, -1);
    int ans = 0;
    while (!Q.empty()) {
        auto [cur, cnt] = Q.front();
        Q.pop();
        int x = 0;
        if (cur->left) x ++;
        if (cur->right) x ++;
        if (cnt == 1) {
            ans ++;
        }
        if (cur->left) {
            Q.emplace(cur->left, x);
        }
        if (cur->right) {
            Q.emplace(cur->right, x);
        }
    }
    return ans;
}

# class Tree:
#     def __init__(self, val, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countOnlyChildInBinaryTree(self, root):
        if not root:
            return 0
        q = deque([(root, -1)])
        ans = 0
        while q:
            cur, cnt = q.popleft()
            if cnt == 1:
                ans += 1
            x = 0
            if cur.left:
                x += 1
            if cur.right:
                x += 1
            if cur.left:                
                q.append((cur.left, x))
            if cur.right:
                q.append((cur.right, x))
        return ans