def test_ispath():
valid_path = [1, 2, 3, 4]
invalid_path = [1, 2, 4, 3]
graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
edges = [(1, 2), (2, 3), (1, 2), (3, 4)]
for graph in graphs:
graph.add_edges_from(edges)
assert nx.is_path(graph, valid_path)
assert not nx.is_path(graph, invalid_path)
def find_adapter_chain(adapter_graph: nx.DiGraph) -> tuple[int, int]:
"""Find a valid chain of adapters & determine how many 1 & 3 joltage deltas are present."""
# NOTE: This approach is super overkill for this problem, but I wanted to stick with the graph
#
# Since our edges represent a valid adapter connection, we're looking for a Hamiltonian path
# here: a path that visits every node exactly once. For this problem, since adapter joltage has
# to be ascending, we can check a topological sort and see if they're all connected.
n_one_delta = 0
n_three_delta = 0
for check_path in nx.all_topological_sorts(adapter_graph):
# First check that the topological sort has yielded a valid path.
if not nx.is_path(adapter_graph, check_path):
continue
# Let's assume there's only one valid path
for source, dest in zip(check_path, check_path[1:]):
delta = adapter_graph.get_edge_data(source, dest)["delta"]
if delta == 1:
n_one_delta += 1
elif delta == 3:
n_three_delta += 1
return n_one_delta, n_three_delta
def path_weight(G, path, weight):
"""Returns total cost associated with specified path and weight
Parameters
----------
G : graph
A NetworkX graph.
path: list
A list of node labels which defines the path to traverse
weight: string
A string indicating which edge attribute to use for path cost
Returns
-------
cost: int
A integer representing the total cost with respect to the
specified weight of the specified path
Raises
------
NetworkXNoPath
If the specified edge does not exist.
"""
multigraph = G.is_multigraph()
cost = 0
if not nx.is_path(G, path):
raise nx.NetworkXNoPath("path does not exist")
for node, nbr in nx.utils.pairwise(path):
if multigraph:
cost += min([v[weight] for v in G[node][nbr].values()])
else:
cost += G[node][nbr][weight]
return cost