为无向图中的所有节点存储 dist(node, start) 的算法

Question

The goal is to create an array called siz that stores the length of all the paths from a starting node. In the ideal case, I would call f(start) and expect siz[v] to get filled up for all vertices v in the graph.

This the algorithm that I am using.

def f (node):
    vis[node] = 1
    for elem in adj[node]:
        if vis[elem]==0:
            for i in siz[node]:
                    siz[elem].append(i + w[(node,elem)])
            f(elem)

Variable descriptions:

1. adj[cur_nod] contains all the neighbors of the node cur_nod
2. siz[cur_nod] (which is a list not an int data type) contains all the distances from node 1 to node cur_nod
3. w(x,y) denotes the weight of the edge joining the nodes x and y
4. vis[nod] tracks if a node is visited. 0 for not, 1 for visited.

The recursion doesn't seem correct and I don't know when to actually mark a node as visited. Also, since there are cycles, I do not want distances to include cycles. For instance, A -> B -> C -> A -> D should not be a case at all. It should just be A -> D or all other ways there is a path from A to D without going through a cycle.

To give an example of how this algorithm doesn't work as intended:

If I enter the nodes and the edge weights as w(1,2)=1, w(2,3)=2, w(2,4)=7 and w(3,4)=1.

Then siz = [[-1], [0], [1], [3], [4]]. (Do note that I have set siz[1]=0 and siz[0]=-1 initially since my start node is 1 and the array is 0-indexed but I need it as 1-indexed) while the ideal siz should have been [[-1], [0], [1], [3,9], [4,8]]

Answer 1

What you may do is simply consider the current path you are traversing. For the last visited node, create the corresponding new path and add it to ' siz ' which I renamed to node_paths . Then recurse for every neighbour.

Since the path given to f (see below code) is a copy you don't have to manually remove the added node (However, if eg you use path.append(node) , when you quit f , you would thus have to path.pop() )

data = [
(1, 2, 1),
(1, 3, 2),
(2, 4, 4),
(3, 4, 8),
]
adj = {}
w = {}
node_paths = {}
for (src, dst, weight) in data:
  if src not in adj:
    adj[src] = []
  if dst not in adj:
    adj[dst] = []

  adj[src].append(dst)
  adj[dst].append(src)
  w[(src, dst)] = weight
  w[(dst, src)] = weight

def f (path, weight, node, node_paths):
  if node in path:
    return
  path_to_node = path + [node]
  weight_to_node = weight + w[(path[-1], node)]
  if node not in node_paths:
    node_paths[node] = []
  node_paths[node].append((path_to_node[1:], weight_to_node))
  for neigh in adj[node]:
    f(path_to_node, weight_to_node, neigh, node_paths)

node_paths = {}
start = 1
w[(-1, start)] = 0
f([-1], 0, start, node_paths)
print(node_paths)

#{1: [([1], 0)], 2: [([1, 2], 1), ([1, 3, 4, 2], 14)], 4: [([1, 2, 4], 5), ([1, 3, 4], 10)], 3: [([1, 2, 4, 3], 13), ([1, 3], 2)]}

In code above, I store both the path and the weighted sum to ease debug, but you may obviously discard the stored path

A few points:

• When debugging just avoid asking user input and hardcode stuff it helps reproducibility and fasten tries
• A nice property of 1,2,4,8 is that (given the binary representation) any combination (among the numbers) you take will yield a different sum which "uniquely" describes your path (even if there we just have the path at disposal anyway)
• I did not follow your algorithm spirit because I think it fails for diamond graphs like the one above (even if no cycle in a directed graph) (since we would probably cumulate identical paths)(but I just guessed it, not tested the guess, and may be wrong)