Here's a possible solution for the given problem:

```cpp
class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> freq; // frequency map
        int maxFreq = 0; // maximum frequency so far
        traverse(root, freq, maxFreq); // traverse the tree and update the frequency map
        vector<int> modes; // output vector
        for (auto [key, count] : freq) { // loop over the frequency map
            if (count == maxFreq) { // if the current key has maximum frequency
                modes.push_back(key); // add it to the output
            }
        }
        return modes;
    }
private:
    void traverse(TreeNode* root, unordered_map<int, int>& freq, int& maxFreq) {
        if (!root) return;
        traverse(root->left, freq, maxFreq);
        maxFreq = max(maxFreq, ++freq[root->val]); // update the frequency of the current node
        traverse(root->right, freq, maxFreq);
    }
};
```

The `findMode` function takes a `TreeNode*` argument and returns a `vector<int>` containing the mode(s) of the BST. It initializes an empty frequency map (`freq`) and a maximum frequency variable (`maxFreq`). Then, it calls the `traverse` function to traverse the tree in an inorder fashion and update the frequency map and maximum frequency.

The `traverse` function is a helper function that takes a `TreeNode*` argument, a reference to the frequency map, and a reference to the maximum frequency variable. It performs an inorder traversal of the tree and updates the frequency map and maximum frequency for each node.

Finally, the `findMode` function loops over the frequency map and adds the keys with maximum frequency to the output vector (`modes`), then returns it. Note that we're using structured bindings (`auto [key, count]`) to simplify the loop over the frequency map.
Scrivete una soluzione in C++ per il seguente problema: data la radice di un albero binario di ricerca (BST) con duplicati, restituite tutti i modi (cioè l'elemento che si è verificato più di frequente) in esso. Se l'albero ha più di una modalità, restituiscile in qualsiasi ordine. Si supponga che un BST sia definito come segue: - Il sottoalbero sinistro di un nodo contiene solo nodi con chiavi inferiori o uguali alla chiave del nodo. - Il sottoalbero destro di un nodo contiene solo nodi con chiavi maggiori o uguali alla chiave del nodo. - Anche i sottoalberi sinistro e destro devono essere alberi di ricerca binari.