递归、树与图：沿着依赖和边访问

#include <algorithm>
#include <iostream>
#include <memory>
struct Node {
    int value;
    std::unique_ptr<Node> left;
    std::unique_ptr<Node> right;
    explicit Node(int v) : value(v) {}
};
int count(const Node* node) { return node ? 1 + count(node->left.get()) + count(node->right.get()) : 0; }
int height(const Node* node) {
    return node ? 1 + std::max(height(node->left.get()), height(node->right.get())) : 0;
}
int main() {
    auto root = std::make_unique<Node>(1);
    root->left = std::make_unique<Node>(2);
    root->right = std::make_unique<Node>(3);
    if (count(nullptr) != 0 || height(nullptr) != 0) return 1;
    std::cout << "count=" << count(root.get()) << " height=" << height(root.get()) << '\n';
}

#include <iostream>
#include <queue>
#include <vector>
std::vector<int> bfs(const std::vector<std::vector<std::size_t>>& graph, std::size_t start) {
    std::vector<int> distance(graph.size(), -1);
    distance.at(start) = 0;
    std::queue<std::size_t> pending;
    pending.push(start);
    while (!pending.empty()) {
        const auto v = pending.front(); pending.pop();
        for (const auto next : graph.at(v)) {
            if (distance.at(next) != -1) continue;
            distance[next] = distance[v] + 1;
            pending.push(next);
        }
    }
    return distance;
}
int main() {
    const std::vector<std::vector<std::size_t>> graph{{1,2},{0,3},{0,3},{1,2},{}};
    const auto d = bfs(graph, 0);
    if (d != std::vector<int>{0,1,1,2,-1}) return 1;
    for (std::size_t i = 0; i < d.size(); ++i) std::cout << (i == 0 ? "" : " ") << d[i];
    std::cout << '\n';
}