Propagating values from the leaf to the root - c++

Question

I have solved quite a few questions related to trees, however, I still don't feel confident about one particular aspect of trees (recursion in general):
How do you propagate values from the leaf to the root?
For example, consider we have a binary tree wherein we have to find the root to leaf path with the minimum sum. For the tree image here, the sum would be 7 (corresponding to two paths 0-3-2-1-1 or 0-6-1).
I wrote the following code:
struct Node
{
int cost;
vector<Node *> children;
Node *parent;
};
int getCheapestCost( Node *rootNode )
{
if(!rootNode) return 0;
return dfs(rootNode, INT_MAX, 0);
}
int dfs(Node* rootNode, int minVal, int currVal) {
if(!rootNode) return;
currVal+=rootNode->cost;
if(rootNode->children.empty()) {
minVal = min(minVal, currVal);
return minVal;
}
for(auto& neighbor: rootNode->children) {
dfs(neighbor, minVal, currVal);
}
return currVal; //this is incorrect, but what should I return?
}
I know the last return currVal is incorrect - but then what should I return? Technically, I only want to return the value of minVal when I reach the leaf nodes (and no value when I am at the intermediate nodes). So, how do I propagate the minVal from the leaf nodes to the topmost root node?
P.S.: I am preparing for interviews and this is a big pain area for me since I get stuck at this point almost every time. I would highly appreciate any help. Thanks.
Edit: For this particular one, I somehow wrote a solution using pass by reference.

Answer 1

Inside your for save the minVal from all children and return minVal instead of currVal.
for(auto& neighbor: rootNode->children) {
minVal = min(minVal, dfs(neighbor, minVal, currVal));
}
return minVal;
That way you're always returning the minVal, through the recursion all the way to the first call.
Edit: Explanation
I'll use the tree you provided in your question as an example. We'll start by entering the tree at the root(0). It'll add 0 to the currVal, won't enter the first if, then enter the for. Once it's there, the function will be called again, from the first child.
At the first node (5), it'll add that value, check if it's the end, and go to the next node (4), adds again, currVal is now 9. Then, since (4) has no children, it'll return min(currVal, minVal). At this point, minVal is INT_MAX, so it returns 9.
Once this value is returned, we go back to the function that called it, which was at node(5), exactly at the point when we called (4), and we'll (with my modification) compare whichever value it returned with minVal.
min(minVal, dfs(neighbor, minVal, currVal))
At this point, it's important to notice that the current minVal is still INT_MAX, as it's not a reference, and this was the value passed to the function. And as a result, we now set it to 9.
If (5) had other children, we would now enter a new instance of dfs and at the once we had a result, compare that value with 9, but since we don't, we end the for loop and return minVal, going back to the root node(0).
From there, I believe you can guess what happens, we enter node(3) which branches to (2)->(1)->(1) and (0)->(10), returning 7 and 13 to the for loop respectively, and node (6) will finally also return 7 to (0)'s for loop.
In the end, (0) will first compare INT_MAX with 9, then with 7 and finally with 7 again, returning 7 to getCheapestCost.
In short:
Your code will keep entering dfs until it finds a node without children, once that happens, it'll return the minVal it got from that node, and return to the function that called it, which is the parent node.
Once in the parent node, you need to check which children provided the minimum minVal, by comparing that with your previous minVal (from other children, branches or INT_MAX). After checking all children, minValue is returned to the next parent, which compares with its children until it reaches the root node.