I had some minor errors in the code I listed. Primarily, the ordered pair index values should have been 0 & 1 for head and tail respectively.

Also, you’ll notice the code never does a search a separate search for nodes without parents. Since the null set is a subset of any set, the criteria for the Parent set to be a subset of the Successor set was already met.

Enum PairType
    head = 0
    tail = 1
End Enum

Dim Nodes As New Scripting.Dictionary
Dim Parents As New Scripting.Dictionary
Dim Successors As New Scripting.Dictionary

Dim Pairs As Variant 'Variant array of ordered pairs

Sub InitPairs()
    'Each pair is comprised of a head/tail duple
    Pairs = Array( _
        Array("AB", "A", "B"), Array("AE", "A", "E"), Array("AF", "A", "F"), _
        Array("BA", "B", "A"), Array("BC", "B", "C"), _
        Array("CB", "C", "B"), Array("CD", "C", "D"), _
        Array("EG", "E", "G"), Array("EH", "E", "H"), _
        Array("HL", "H", "L"), _
        Array("IJ", "I", "J"), Array("IK", "I", "K") _
        )
End Sub

Sub Main()
    Dim pr, i As Long, node As Variant, hasParent As Boolean
    Dim parStr As String, parCh As String, succStr As String, Missing As Boolean
    'Init pairs and create node list

    InitPairs
    For Each pr In Pairs
        If Not Nodes.Exists(pr(head)) Then Nodes.Add pr(head), pr(head)
        If Not Nodes.Exists(pr(tail)) Then Nodes.Add pr(tail), pr(tail)
    Next pr

    '
    For Each node In Nodes
        Parents.Add node, ""
        Successors.Add node, ""
    Next node

    For Each pr In Pairs
        If (InStr(Parents(pr(tail)), pr(head)) = 0) Then
            Parents(pr(tail)) = Parents(pr(tail)) & pr(head)
        End If
        If (InStr(Successors(pr(head)), pr(tail)) = 0) Then
            Successors(pr(head)) = Successors(pr(head)) & pr(tail)
        End If
    Next pr

    For Each node In Nodes
        parStr = Parents(node)
        Missing = False
        succStr = Successors(node)
        For i = 1 To Len(parStr)
            parCh = Mid(parStr, i, 1)
            If InStr(succStr, parCh) = 0 Then Missing = True: Exit For
        Next i
        If Not Missing Then Debug.Print node & " is senior node"
    Next node
    Set Nodes = Nothing
    Set Parents = Nothing
    Set Successors = Nothing
End Sub

That sounds promising. I think I’ll code that up, and see how it works with my real data.

By the way, in case you’re wondering, I’m using Qt to build a QTreeView (QStandardItem-based) to represent the graph in tree form. My data is in the form of a QMap<Object*,QSet<Object*>> such that each of the map’s keys maps to a set of children. The map is in no particular order.

–Dave

I would evaluate each ordered pair’s head and tail to create a Parent set and Successor set for each node. Then I’d evaluate each set to see if it met the senior node criteria.

Processing your directed graph, seems to yield the proper result as do the corner cases I tried.

I am not sure I understand what you are saying. The Warshall algorithm will tell you for each pair of nodes (A,B) if A is a descendant of B. This allows you to go through all the nodes and compute descendant counts for each node. Once you have the counts, the most senior node is the one with the maximum number of descendants.

But actually looking at your graph with the “I” node, I realize that you were asking a different question. I think you need to formulate it more precisely, though. What exactly makes a node senior? Give a rule that will make node I more senior than node E.

One idea – split the graph into fully connected sub-graphs that are not connected with each other, and then declare a node to be “senior” if it has the most descendants in its sub-graph. In that case, the problem is split in two – build the connectivity matrix with the Warshall algorithm, then sub-divide the result. Subdivision can be done like this:

For each remaining node, pick the one with the most descendants. Exclude it along with all of its descendants. Repeat until empty.

That looks pretty. I think it works just right (still looking it over).

–Dave

def influences(graph):
    sources = set([edge[0] for edge in graph])
    sinks = set([edge[1] for edge in graph])

    parents = dict([(s, set()) for s in sinks])
    inf = dict([(s, set()) for s in sources])
    updated = set()

    for (a, b) in graph:
        parents[b].add(a)
        inf[a].add(b)
        updated.add(a)

    while updated:
        n = updated.pop()
        hits = inf[n]
        for p in parents.get(n, []):
            phits = inf[p]
            if hits.issubset(phits): continue
            phits.update(hits)
            updated.add(p)

    return inf

def supernodes(graph):
    inf = influences(graph)
    reach = dict([(a, len(b)) for (a, b) in inf.iteritems()])
    supers = set()
    while reach:
        x = max([b for (a, b) in reach.iteritems()])
        print 'max', x
        new = [a for (a, b) in reach.iteritems() if b == x]
        print 'new', new
        supers.update(new)
        for n in new:
            if n in reach: del reach[n]
            for m in inf[n]:
                if m in reach: del reach[m]
        print reach
    return supers

graph = [('a', 'b'),
         ('a', 'e'),
         ('a', 'f'),
         ('b', 'a'),
         ('b', 'c'),
         ('c', 'b'),
         ('c', 'd'),
         ('e', 'g'),
         ('e', 'h'),
         ('h', 'l'),
         ('i', 'j'),
         ('i', 'k')]

print supernodes(graph)

And base64-protected :) —

ZGVmIGluZmx1ZW5jZXMoZ3JhcGgpOgogICAgc291cmNlcyA9IHNldChbZWRnZVswXSBmb3IgZWRn
ZSBpbiBncmFwaF0pCiAgICBzaW5rcyA9IHNldChbZWRnZVsxXSBmb3IgZWRnZSBpbiBncmFwaF0p
CgogICAgcGFyZW50cyA9IGRpY3QoWyhzLCBzZXQoKSkgZm9yIHMgaW4gc2lua3NdKQogICAgaW5m
ID0gZGljdChbKHMsIHNldCgpKSBmb3IgcyBpbiBzb3VyY2VzXSkKICAgIHVwZGF0ZWQgPSBzZXQo
KQoKICAgIGZvciAoYSwgYikgaW4gZ3JhcGg6CiAgICAgICAgcGFyZW50c1tiXS5hZGQoYSkKICAg
ICAgICBpbmZbYV0uYWRkKGIpCiAgICAgICAgdXBkYXRlZC5hZGQoYSkKCiAgICB3aGlsZSB1cGRh
dGVkOgogICAgICAgIG4gPSB1cGRhdGVkLnBvcCgpCiAgICAgICAgaGl0cyA9IGluZltuXQogICAg
ICAgIGZvciBwIGluIHBhcmVudHMuZ2V0KG4sIFtdKToKICAgICAgICAgICAgcGhpdHMgPSBpbmZb
cF0KICAgICAgICAgICAgaWYgaGl0cy5pc3N1YnNldChwaGl0cyk6IGNvbnRpbnVlCiAgICAgICAg
ICAgIHBoaXRzLnVwZGF0ZShoaXRzKQogICAgICAgICAgICB1cGRhdGVkLmFkZChwKQoKICAgIHJl
dHVybiBpbmYKCmRlZiBzdXBlcm5vZGVzKGdyYXBoKToKICAgIGluZiA9IGluZmx1ZW5jZXMoZ3Jh
cGgpCiAgICByZWFjaCA9IGRpY3QoWyhhLCBsZW4oYikpIGZvciAoYSwgYikgaW4gaW5mLml0ZXJp
dGVtcygpXSkKICAgIHN1cGVycyA9IHNldCgpCiAgICB3aGlsZSByZWFjaDoKICAgICAgICB4ID0g
bWF4KFtiIGZvciAoYSwgYikgaW4gcmVhY2guaXRlcml0ZW1zKCldKQogICAgICAgIHByaW50ICdt
YXgnLCB4CiAgICAgICAgbmV3ID0gW2EgZm9yIChhLCBiKSBpbiByZWFjaC5pdGVyaXRlbXMoKSBp
ZiBiID09IHhdCiAgICAgICAgcHJpbnQgJ25ldycsIG5ldwogICAgICAgIHN1cGVycy51cGRhdGUo
bmV3KQogICAgICAgIGZvciBuIGluIG5ldzoKICAgICAgICAgICAgaWYgbiBpbiByZWFjaDogZGVs
IHJlYWNoW25dCiAgICAgICAgICAgIGZvciBtIGluIGluZltuXToKICAgICAgICAgICAgICAgIGlm
IG0gaW4gcmVhY2g6IGRlbCByZWFjaFttXQogICAgICAgIHByaW50IHJlYWNoCiAgICByZXR1cm4g
c3VwZXJzCgpncmFwaCA9IFsoJ2EnLCAnYicpLAogICAgICAgICAoJ2EnLCAnZScpLAogICAgICAg
ICAoJ2EnLCAnZicpLAogICAgICAgICAoJ2InLCAnYScpLAogICAgICAgICAoJ2InLCAnYycpLAog
ICAgICAgICAoJ2MnLCAnYicpLAogICAgICAgICAoJ2MnLCAnZCcpLAogICAgICAgICAoJ2UnLCAn
ZycpLAogICAgICAgICAoJ2UnLCAnaCcpLAogICAgICAgICAoJ2gnLCAnbCcpLAogICAgICAgICAo
J2knLCAnaicpLAogICAgICAgICAoJ2knLCAnaycpXQoKcHJpbnQgc3VwZXJub2RlcyhncmFwaCkK

The Warshall algorithm will certainly find all the nodes and their descendants’ tree height. I don’t argue that. What I find wrong with your approach is measuring the depth of each nodes’ descendants tree and choosing the parent nodes with the maximum height. In the third figure above, that would omit node “I”, not because “I” is part of a disconnected graph, but because its tree height is smaller than that of “A”, “B”, and “C”.

Warshall algorithm will find all nodes. It does not really care if the graph is fully connected since it works with a connectivity matrix rather than starting from a node and traversing the graph. Basically the idea is that for each node we pour colored water into it and then see which other nodes eventually have water of that color.

Let me explain the problem’s context. I am developing a GUI that uses a common tree view, like what you might see in a file browser. I am given a graph like the ones pictured above, and need to translate that into the tree view display full of expandable and collapsible nodes (with possibly multiple root nodes).

Does that help at all?