Approach: DFS carrying parent and grandparent

def sumEvenGrandparent(self, root):
    def dfs(node, p, g):
        if not node: return 0
        s = node.val if (g and g.val % 2 == 0) else 0
        return s + dfs(node.left, node, p) + dfs(node.right, node, p)
    return dfs(root, None, None)

Complexity: O(n) time, O(h) space.

Full Solution — all languages

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def sumEvenGrandparent(self, root):
        def dfs(node, p, g):
            if not node: return 0
            s = node.val if (g and g.val % 2 == 0) else 0
            return s + dfs(node.left, node, p) + dfs(node.right, node, p)
        return dfs(root, None, None)

import java.util.*;
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) {
        val = v;
    }
}
class Solution {
    public int sumEvenGrandparent(TreeNode root) {
        return dfs(root, null, null);
    }
    private int dfs(TreeNode node, TreeNode p, TreeNode g) {
        if (node == null) return 0;
        int s = (g != null && g.val % 2 == 0) ? node.val : 0;
        return s + dfs(node.left, node, p) + dfs(node.right, node, p);
    }
}

#include <bits/stdc++.h> using namespace std;
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {
    }
};
class Solution {
    public: int sumEvenGrandparent(TreeNode* root) {
        function<int(TreeNode*,TreeNode*,TreeNode*)> dfs = [&](TreeNode* node, TreeNode* p, TreeNode* g) -> int {
            if (!node) return 0;
            int s = (g && g->val % 2 == 0) ? node->val : 0;
            return s + dfs(node->left, node, p) + dfs(node->right, node, p);
        };
        return dfs(root, nullptr, nullptr);
    }
};

/**
 * Tree node shape: { val, left, right }
 * @param {TreeNode} root
 * @return {number}
 */ var sumEvenGrandparent = function(root) {
    const dfs = (node, p, g) => {
        if (!node) return 0;
        const s = (g && g.val % 2 === 0) ? node.val : 0;
        return s + dfs(node.left, node, p) + dfs(node.right, node, p);
    };
    return dfs(root, null, null);
};

Sum of Nodes with Even-Valued Grandparent

Example 1

Example 2

Constraints