int solve(Node *root) {
    int res = 0;

    auto dfs = [&] (auto self, Node *node, int height) {
        if (node == nullptr) {
            res = max(res, height);
            return;
        }
        if (node->data % 2 == 0) {
            ++height;
        }
        self(self, node->left, height);
        self(self, node->right, height);
    };

    dfs(dfs, root, 0);
    return max(res - 1, 0);
}

void solve(vector<vector<char>>& board, string word) {
    int m = board.size();
    int n = board[0].size();
    bool containsWord = false;

    visited<pair<int, int>> visited;

    auto bfs = [&] (auto self, int i, int j, int idx) {
        if (min(i, j) < 0 || i >= m || j >= n || containsWord) {
            return;
        }
        if (visited.find({i, j}) != visited.end()) {
            return;
        }
        if (idx == word.size()) {
            containsWord = true;
            return;
        }
        visited.insert({i, j});
        if (board[i][j] == word[idx]) {
            self(self, i, j + 1);
            self(self, i, j - 1);
            self(self, i + 1, j);
            self(self, i - 1, j);
        }
        visited.erase({i, j});
    };

    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            bfs(bfs, i, j, 0);
            if (containsWord) {
                break;
            }
        }
        if (containsWord) {
            break;
        }
    }
    cout << boolalpha << res << endl;
}