






A__			:    int         =				{
    'A': ['B', 'C', 'E'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F', 'G'],
    'D': ['B'],
    'E': ['A', 'B', 'D'],
    'F': ['C'],
    'G': ['C'],
}






def 						a    (		lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''
				lowercase__     				=    set()
				# keep track of all the paths to be checked
				lowercase__     				=    [[start]]

				# return path if start is goal
				if start == goal:
								return [start]

				# keeps looping until all possible paths have been checked
				while queue:
								# pop the first path from the queue
								lowercase__     				=    queue.pop(0       )
								# get the last node from the path
								lowercase__     				=    path[-1]
								if node not in explored:
												lowercase__     				=    graph[node]
												# go through all neighbour nodes, construct a new path and
												# push it into the queue
												for neighbour in neighbours:
																lowercase__     				=    list(lowerCamelCase_       )
																new_path.append(lowerCamelCase_       )
																queue.append(lowerCamelCase_       )
																# return path if neighbour is goal
																if neighbour == goal:
																				return new_path

            # mark node as explored
												explored.add(lowerCamelCase_       )

    # in case there's no path between the 2 nodes
				return []






def 						a    (		lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''
				if not graph or start not in graph or target not in graph:
								return -1
				if start == target:
								return 0
				lowercase__     				=    [start]
				lowercase__     				=    set(lowerCamelCase_       )
				# Keep tab on distances from `start` node.
				lowercase__     				=    {start: 0, target: -1}
				while queue:
								lowercase__     				=    queue.pop(0       )
								if node == target:
												lowercase__     				=    (
												    dist[node] if dist[target] == -1 else min(dist[target]	,     dist[node]       )
												)
								for adjacent in graph[node]:
												if adjacent not in visited:
																visited.add(lowerCamelCase_       )
																queue.append(lowerCamelCase_       )
																lowercase__     				=    dist[node] + 1
				return dist[target]


if __name__ == "__main__":
							print(bfs_shortest_path(demo_graph, 'G', 'D'))  # returns ['G', 'C', 'A', 'B', 'D']
							print(bfs_shortest_path_distance(demo_graph, 'G', 'D'))  # returns 4












from collections import defaultdict
from math import gcd






def 						a    (		lowerCamelCase_ = 150_0000       ):






				'''simple docstring'''
				lowercase__     				=    defaultdict(lowerCamelCase_       )
				lowercase__     				=    2
				while 2 * euclid_m * (euclid_m + 1) <= limit:
								for euclid_n in range((euclid_m % 2) + 1	,     lowerCamelCase_	,     2       ):
												if gcd(lowerCamelCase_	,     lowerCamelCase_       ) > 1:
																continue
												lowercase__     				=    2 * euclid_m * (euclid_m + euclid_n)
												for perimeter in range(lowerCamelCase_	,     limit + 1	,     lowerCamelCase_       ):
																frequencies[perimeter] += 1
								euclid_m += 1
				return sum(1 for frequency in frequencies.values() if frequency == 1       )


if __name__ == "__main__":
							print(F"{solution() = }")




