Recursive tree sum without defining a tree structure - recursion

Question

I have a dictionary (1) of nodes and child nodes Dictionary<int,int[]> and a list (2) of Weights associated to each nodes. The dictionary can be interpreted as follows: e.g.: key 1 has values 3,4 which means that the node id=1 is parent to nodes 3 and 4. key 3 has values 5,6,8 which means that node id=3 is parent to nodes 5,6 and 8... etc. The second list is just a list of weights where the index represents the node id the weight is associated to.
I want to calculate for each key nodes of list (1) its sum of all child nodes weights.
I think this problem is similar to a recursive tree sum, although my lists aren't setup as tree structures.
How should I proceed?

Answer 1

Here a Python version of a solution to what you want to achieve:
dctNodeIDs_vs_Childs = {}
dctNodeIDs_vs_Childs[1] = (2,3,4)
dctNodeIDs_vs_Childs[2] = (13,14,15)
dctNodeIDs_vs_Childs[3] = (5,6,7,8)
dctNodeIDs_vs_Childs[4] = (9,10,11,12)
lstNodeIDs_vs_Weight = [None,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
def getSumOfWeights(currNodeID, lstNodeIDs_vs_Weight = lstNodeIDs_vs_Weight, dctNodeIDs_vs_Childs = dctNodeIDs_vs_Childs):
sumOfWeights = 0
print("#currNodeID", currNodeID)
if currNodeID not in dctNodeIDs_vs_Childs:
sumOfWeights += lstNodeIDs_vs_Weight[currNodeID]
else:
for childNodeID in dctNodeIDs_vs_Childs[currNodeID]:
print("## childNodeID", childNodeID)
if childNodeID not in dctNodeIDs_vs_Childs:
sumOfWeights += lstNodeIDs_vs_Weight[childNodeID]
else:
sumOfWeights += lstNodeIDs_vs_Weight[childNodeID] + sum( [ getSumOfWeights(nodeID) for nodeID in dctNodeIDs_vs_Childs[childNodeID] ] )
return sumOfWeights
lstNodeIDs_vs_WeightsOfChildNodes = [None for _ in range(len(lstNodeIDs_vs_Weight)+1)]
for nodeID in dctNodeIDs_vs_Childs.keys():
print("nodeID =", nodeID)
lstNodeIDs_vs_WeightsOfChildNodes[nodeID] = getSumOfWeights(nodeID)
print("---")
print(lstNodeIDs_vs_WeightsOfChildNodes)
which give following output:
nodeID = 1
#currNodeID 1
## childNodeID 2
#currNodeID 13
#currNodeID 14
#currNodeID 15
## childNodeID 3
#currNodeID 5
#currNodeID 6
#currNodeID 7
#currNodeID 8
## childNodeID 4
#currNodeID 9
#currNodeID 10
#currNodeID 11
#currNodeID 12
nodeID = 2
#currNodeID 2
## childNodeID 13
## childNodeID 14
## childNodeID 15
nodeID = 3
#currNodeID 3
## childNodeID 5
## childNodeID 6
## childNodeID 7
## childNodeID 8
nodeID = 4
#currNodeID 4
## childNodeID 9
## childNodeID 10
## childNodeID 11
## childNodeID 12
---
[None, 119, 42, 26, 42, None, None, None, None, None, None, None, None, None, None, None, None]

Answer 2

A colleague at work came up with this elegant solution (2 dictionaries needed). Might not be the most efficient one though.
double MethodName(int Id) => FirstDic.ContainsKey(Id) ? FirstDic[Id].Sum(n => MethodName(n)) : SecondDic.Where(y => y.Key == Id).Select(x => x.Value).Sum();