如何在Neo4j中找到关键节点？

Question

So, assume a very simple graph

(A)->(B)->(D)->(E) | (A)->(C)->(D)->(E)

Which will look something like <>- if you visualize it.

A critical node in a graph is one where if you remove it, you will now have 2 graphs. (AKA, a single point of failure)

So in this example, E is not critical, because it is a leaf, and B and C are not critical because A and D are still connected by the other node. D is critical though because removing it will orphan E from the rest of the graph.

Using Cypher, how do I find the critical node(s)? (in this case, D)

---

My first instinct is to take all paths, and count how many times each node is touched, but that would be horrible inefficient and unreliable. My second instinct is something like WHERE NONE (n in path WHERE NOT n in OTHER_PATHS) , but even if I could figure out how to make that work, I wouldn't know which node(s) in the path was critical.

I found this blog, but it seems to assume you already know something about the critical nodes.

Answer 1

We can approach this through its definition:

A critical node in a graph is one where if you remove it, you will now have (at least) 2 graphs.

Or put another way, if all nodes are initially reachable from each other, and if we remove a node, and this changes the number of nodes reachable from any other node in the graph, then that removed node is a critical node.

The big obstacle with attempting this via Cypher alone is that Cypher variable-length path matches are designed to find all possible paths, so it's inefficient at finding all reachable nodes.

Using APOC Path expander procedures we can change the uniqueness used during the traversal so we only ever find a single path to each distinct node and dismiss all others, cutting down the number of paths we need to explore, making it much faster at finding all reachable nodes in the graph.

Using this, we can first compute all nodes in the graph, then for every node, see if blacklisting that node during expansion (effectively seeing what happens when we remove the node) causes expansion from another node to find less than the entire graph (-1 of course, for the node we "removed").

You will need to use an APOC version newer than the Summer 2018 releases ( >= 3.3.0.4 on the 3.3.x line, or >= 3.4.0.2 on the 3.4.x line) in order to use this approach, as the blacklistNodes feature we need was added with this release.

Here's the general approach, assuming that we're considering all nodes, and that all nodes in the graph are initially reachable from each other.

MATCH (n)
WITH collect(n) as allNodes
WITH allNodes, size(allNodes) - 1 as totalNodes, allNodes[..2] as startNodes
// using total as one less than the actual total since we're 'removing' a node.
// 2 potential start nodes so we always have one if the other is to be removed.
UNWIND allNodes as nodeToRemove
// we now have each node in the graph on its row, we'll try removing each one
WITH [node in startNodes WHERE node <> nodeToRemove][0] as startNode, nodeToRemove, totalNodes
CALL apoc.path.subgraphNodes(startNode, {blacklistNodes:[nodeToRemove]}) YIELD node
WITH totalNodes, nodeToRemove, count(node) as reachableNodes
WHERE totalNodes <> reachableNodes
RETURN nodeToRemove as criticalNode

Answer 2

First, You need to identify the type of nodes you have in your graph: if all the nodes are the same type, so you can count all their relationships (or specific relationships); if a node have more than n relationships (maybe 2) it could be a critical node, else this node not be critical.

But if you have more than 1 type of nodes, You need to identify which kind of nodes and relationships are more important, then query each kind of nodes and relationships, and finally count their relationships (all relationships or specific relationships) to all the kind of nodes or specific nodes

MATCH (n)-[r]->() RETURN COUNT(r)

And if the node is considered like not critical, you can proceed to delete this node.

Answer 3

I figured out how to do path based filtering where a condition needs to be true on every possible path. You can use pattern recognition in a predicate to filter on all paths. (I use reasonable path length limits for my set to limit runaway. If an alternate path exists in my graph, I expect a short detour. So adjust based on your expectations)

MATCH (a)-[*..10]->(c)-[*..10]->(b) 
WHERE ALL(p in (a)-[*..20]->(b) WHERE c in NODES(p)) 
RETURN DISTINCT c

---

I also tried using allShortestPaths like this, but in my example set, the performance was actually worse. Your mileage my very.

MATCH (a)-[*..10]->(c)-[*..10]->(b) 
WHERE ALL(p in allShortestPaths((a)-[*..20]->(b)) WHERE c in NODES(p)) 
RETURN DISTINCT c