Get sequence of common Nodes in two Neo4j Paths - neo4j

Question

Let's have for example the following travel routes in Neo4j:
Tom: New York --> Moskow --> Berlin --> Paris --> Mumbay --> Kairo --> Rio --> Amsterdam --> Nashville
Mary: Madrid --> New York --> Moskow --> Berlin --> Mumbay --> Kairo --> New York --> Nashville --> Toronto
Bob: New York --> Nashville --> Amsterdam --> Rio --> Kairo --> Mumbay --> Paris --> Berlin --> Moscow
Now I need to get the travel route that is most similar to Tom's route. Similarity means, the number of common cities that are visited in the same sequence, while skipping cities in between is allowed.
Expected result:
Common route of Tom and Mary: New York -> Moskow -> Berlin -> Mumbay -> Kairo -> Nashville => Similarity = 6
Common route of Tom and Bob: New York -> Nashville (also New York -> Amsterdam and other paths) => Similarity = 2
Note: Even Tom and Bob have 9 common cities, but they are not in the same sequence, this is not counting for similarity!
Is it possible with Neo4j to get this kind of similarity?
I would be able to read all the paths and then compare them outside of Neo4j. But better would be to do this with Neo4j, because it will be more elegant and probably faster.
Added:
My current algorithm is a similarity matrix, where I have one path on the x-axis and another on the y-axis. Every match between x and y causes an increment of all values that are on right side and below the match. I other words, every value in the matrix represents the count of the common path before the cell.
Condition to increment a value is that the value is not already greater. This may happen if there are several common paths, in this case the longest path must win.
Two examples of matrix of above examples:
Full Java code:
public static int getLongestCommonWordsInSequence(List<String> yList, List<String> xList) {
// right = X, left = Y
// Need dimension +1, because matches-count is incremented not on match point, but on next indexes
int[][] matrix = new int[xList.size() + 1][yList.size() + 1];
// Iterate y
for (int y = 0; y < yList.size(); y++) {
// Iterate x
for (int x = 0; x < xList.size(); x++) {
// Check if y = x
if (yList.get(y).equals(xList.get(x))) {
// Increment the count
int newCount = matrix[x][y] + 1;
// Update all counts that are on right side AND below the current match
for (int _x = x + 1; _x <= xList.size(); _x++) {
for (int _y = y + 1; _y <= yList.size(); _y++) {
// Update only if value is < newCount
if (matrix[_x][_y] < newCount) {
matrix[_x][_y] = newCount;
}
}
}
}
}
}
return matrix[matrix.length - 1][matrix[matrix.length - 1].length - 1];
}
Added
This is my Java code I would use to create the data of a single journey. This is only experimental. I will extend it or create any other structure if it is of advantage.
Node journeyNode = graphDb.createNode(Label.label("Journey"));
for (Destination destination : journey.destinations) {
Node destinationNode = graphDb.createNode(Label.label("Destination"));
destinationNode.setProperty("name", destination.name);
journey.createRelationshipTo(destinationNode, RelationshipType.withName("Destination"));
}