Neo4J, получая все пути и кратчайший путь

Question

У меня есть 20 узлов и 21 путь, который должен представлять лабиринт.

Теперь я хочу найти все возможные пути (есть 3) от начала до конца.

Я также хочу найти путь с наименьшим количеством веса, в случае наименьшего количества повреждений.

Любая помощь с правильным синтаксисом и какие-либо советы по улучшению очень ценится,

Это querys, что я пробовал, не понятые и не в ..

MATCH p=(a {name:"START"})-[:PATH*tall woods..guard]->(s{name:"Finish"}) RETURN p AS shortestPath, reduce(length=0, r in relationships(p) | length+r.length) AS totalLength order by totalLength

MATCH p=(a {name:"START"})-[:ROAD*tall woods..guard]->(s{name:"Finish"}) RETURN p AS shortestPath, reduce(length=0, r in relationships(p) | length+r.length) AS totalLength order by totalLength limit 1

Я предполагаю, что [: Path * tall woods..guard] неверен, должен ли я писать все пути, разделенные запятой или чем-то еще?

Это мой лабиринт:

create(a:LABYRINTH {name:"START"})-[:PATH {name:"spiders", damage:1}]-> (b:LABYRINTH{name:"B"}), 
(a)-[:PATH {name:"tall woods", damage:1}]->(c:LABYRINTH {name:"C"}), 
(c)-[:PATH {name:"lizards", damage:1}]->(d:LABYRINTH {name:"D"}), 
(c)-[:PATH {name:"gremlins", damage:3}]-> (e:LABYRINTH {name:"E"}), 
(e)-[:PATH {name:"dark woods", damage:0}]->(f:LABYRINTH {name:"F"}), 
(e)-[:PATH {name:"old bridge", damage:2}]->(g:LABYRINTH {name:"G"}), 
(g)-[:PATH {name:"orc", damage:5}]->(i:LABYRINTH {name:"I"}), 
(i)-[:PATH {name:"dead end", damage:0}]->(h: LABYRINTH {name:"H"}), 
(i)-[:PATH {name:"dusty planes", damage:0}]->(j: LABYRINTH {name:"J"}), 
(i)-[:PATH {name:"ape", damage:3}]->(k: LABYRINTH {name:"K"}), 
(k)-[:PATH {name:"mob", damage:1}]->(q: LABYRINTH {name:"Q"}), 
(g)-[:PATH {name:"woods", damage:0}]->(z: LABYRINTH {name:"Z"}), 
(z)-[:PATH {name:"dead planes", damage:0}]->(k), 
(z)-[:PATH {name:"desert", damage:1}]->(m: LABYRINTH {name:"M"}), 
(m)-[:PATH {name:"gorilla", damage:0}]->(n: LABYRINTH {name:"N"}), 
(m)-[:PATH {name:"bridge", damage:0}]->(l: LABYRINTH {name:"L"}), 
(l)-[:PATH {name:"mud", damage:1}]->(o: LABYRINTH {name:"O"}), 
(i)-[:PATH {name:"waters", damage:2}]->(r: LABYRINTH {name:"R"}), 
(r)-[:PATH {name:"witch", damage:1}]->(p: LABYRINTH {name:"P"}), 
(q)-[:PATH {name:"guard", damage:0}]->(s: LABYRINTH {name:"Finish"}), 
(r)-[:PATH {name:"old witch", damage:1}]->(s) 

Answer 1

При использовании variable length relationships, вам нужно использовать целые числа, чтобы определить минимальное и максимальное число отношений обходов (это необязательно), вы не можете поставить значения свойств здесь.

Я настоятельно рекомендую вам прочитать руководство для разработчиков, особенно когда вы сталкиваетесь с стенами, пытаясь заставить что-то работать. Быстрая проверка отношений переменных легко выявила бы правильные способы использования этой функциональности.

Чтобы найти все возможные пути, вы хотите, чтобы соответствовать на вашем старт и финиш узлах, а затем использовать спичку с использованием переменных отношений между ними:

MATCH (a:LABYRINTH {name:"START"}), (s:LABYRINTH {name:"Finish"}) 
MATCH p = (a)-[:PATH*]->(s) 
RETURN p 

Насколько кратчайшими наималейшим весом, проще всего использовать dijkstra function после установки APOC Procedures. Вам нужно будет указать начальный и конечный узлы, фильтр типов отношений и направление для перемещения, а также свойство отношения для использования для веса.

MATCH (start:LABYRINTH{name:'START'}), (end:LABYRINTH{name:'Finish'}) 
CALL apoc.algo.dijkstra(start, end, 'PATH>', 'damage') YIELD path, weight 
RETURN path, weight 

EDIT

В ответ на то, как сделать это без процедур АПБО (хотя рекомендуется, установка примерно так же легко, как это происходит, и вы получите совсем немного полезной функциональности), вы можете сделать это, но вам нужно будет произвести оценку веса самостоятельно.

Вы сделаете это, используя функцию reduce(), которую вы можете использовать в коллекции отношений на своем пути, чтобы получить сумму ущерба, а затем сортировать на основе этой суммы и получить путь с наименьшим наносить ущерб.

MATCH p=(:LABYRINTH {name:"START"})-[rels:PATH*]->(:LABYRINTH {name:"Finish"}) 
WITH p, REDUCE(weight=0, rel in rels | weight + rel.damage) as damage 
RETURN p, damage 
ORDER BY damage ASC 
LIMIT 1