递归可能的所有路径查找器

Question

For example I have points like this:

[[4, 5], [4, 6], [5, 6], [5, 4], [6, 5], [7, 5]]

I want to find all POSSIBLE paths. It can start from every single point if it fits the criteria.

I mean with possible is: In result array there can not be a point that doesn't touch its previous or next point. [4, 5] [7, 5] [7, 6] is not possible because i indexes(4 and 7) are not touching. [4, 6] [5, 4] is not possible because j indexes(6 and 4) are not touching.

At the end I try to have something like this:

[[[4, 5], [4, 6], [5, 6]],
[[4, 6], [5, 6], [6, 6]],
[[5, 6], [4, 6], [4, 5], [5, 4], [6, 5], [7, 5]]

I tried to achieve this with recursion like this. This is a working python code but nothing close to what i want for now :)

points_array = [[4, 5], [4, 6], [5, 6],
                [5, 4], [6, 5], [7, 5]]

possible_points = []


def find_all_possible_paths(left_points,
                            start_point,
                            current_path):
    if len(left_points) == 0:
        if len(current_path) > 3:
            possible_points.append(current_path)
        return

    is_left_any_touching_point = False

    for point in left_points:
        #Take prev_start_point and current_point indexes
        start_point_i = start_point[0]
        start_point_j = start_point[1]

        current_point_i = point[0]
        current_point_j = point[1]

        # IF POINTS ARE TOUCHING add it to list and continue recursion
        if abs(current_point_i - start_point_i) \
                <= 1 and abs(current_point_j - start_point_j) <= 1:
            is_left_any_touching_point = True
            current_path.append(point)
            left_points.remove(point)
            find_all_possible_paths(left_points, point, current_path)

    if not is_left_any_touching_point:
        if len(current_path) > 3:
            possible_points.append(current_path)
        return


#For every start point, try to find every possible paths (We delete start point)
for i in range(0, len(points_array) - 1):
    temp_array = points_array.copy()
    del temp_array[i]
    find_all_possible_paths(temp_array, points_array[i], [])


print(possible_points)

Answer 1

If I understand your criteria, the following should work.

That said, I may misunderstand your criteria since I'm finding a lot of paths that your code does not. But the paths look like they follow the stated rules.

def path_iter(points):
    point_tree = {}
    for point in points:
        if point[0] not in point_tree:
            point_tree[point[0]] = set()
        point_tree[point[0]].add(point[1])

    def recur (path):
        yielded = False
        i, j = path[-1]
        for i1 in [i-1, i, i+1]:
            if i1 in point_tree:
                for j1 in [j-1, j, j+1]:
                    if j1 in point_tree[i1] and [i1, j1] not in path:
                        path.append([i1, j1])
                        yield from recur(path)
                        path.pop()
                        yielded = True
        if not yielded and 3 < len(path):
            yield list(path)

    for point in points:
        yield from recur([point])

for path in path_iter(points_array):
    print(path)