Question

如果作为参数的图形（有向图）具有负权重的循环，我需要创建一个返回true的测试，否则返回false。

现在我创造了这个。理论上应该检查是否有＆＃34;泛型＆＃34;循环，而不是有负循环。我该如何更改方法？那是一个更容易或更有效的方法吗？

//if there is a negative cycle, get out and return 
public void bellmanFord(Graph<V, E> graph, V source, V dest) {
    ArrayList<V> vertices = (ArrayList<V>) graph.getVertices();
    HashMap<V, Boolean> visited = new HashMap<V, Boolean>(vertices.size());
    for(V v : vertices) { 
        visited.put(v, false);
    }
    boolean cycle = hasNegativeCycle(graph, source, visited, vertices);
    if(cycle == true)
        return;
    else {
        ...
    }

}

public boolean hasNegativeCycle(Graph<V, E> graph, V source, HashMap<V, Boolean> visited, ArrayList<V> vertices) {
    visited.put(source, true);
    for(V u : vertices) {
      ArrayList<V> neigh_u = (ArrayList<V>) graph.getNeighbors(u);
      for(V v : neigh_u) {
        if(visited.get(v) == true || hasNegativeCycle(graph, v, visited, vertices)) {
          return true;
        }
      }
    }
    return false;
}

由于

编辑：从你写的方法名称可以看出，我试图实现Bellman-Ford的算法，并且我正在遵循这个伪代码：

BellmanFord(Graph G, Vertex start) { 
    foreach(Vertex u of G) { 
        dist[u] = ∞; 
        prev[u] = -1; 
    } 
    prev[start] = s; 
    dist[start] = 0; 
    repeat n times { 
        foreach(Vertex u of G) { 
            foreach(Vertex v near u) { 
                if(dist[u] + weigth_uv < dist[v]) { 
                    prev[v] = u; 
                    dist[v] = dist[u] + weigth_uv; 
                } 
            } 
        } 
    } 
}

Answer 1

您可能想要对图表进行BFS遍历。在每个节点访问时，将节点的唯一id（例如，如果实现的话，.hashCode（））记录到HashSet中。每当您尝试将已存在的元素插入到散列集中时，您都会找到一个圆圈。

如果你在节点F中找到了一个圆圈，你可以通过向上遍历树来计算圆的总和权重，直到你再次找到F并对权重求和。

当然在确定圆圈大小后，它是肯定的，你必须继续BFS遍历，但不要穿越F的孩子。如果它是负数，则从函数返回，因为你发现了一个负数圈。

编辑：您还可以在BFS遍历步骤中跟踪当前总和权重，这样您就不必向上遍历树来计算总权重...当您的图表是定向时，这方法也适合更好......

Answer 2

您必须应用Bellman-Ford算法。Wikipedia具有适当的伪代码。如果您正确应用此问题，您的问题将得到解决。

function BellmanFord(list vertices, list edges, vertex source)
   ::distance[],predecessor[]

   // This implementation takes in a graph, represented as
   // lists of vertices and edges, and fills two arrays
   // (distance and predecessor) with shortest-path
   // (less cost/distance/metric) information

   // Step 1: initialize graph
   for each vertex v in vertices:
       if v is source then distance[v] := 0
       else distance[v] := inf
       predecessor[v] := null

   // Step 2: relax edges repeatedly
   for i from 1 to size(vertices)-1:
       for each edge (u, v) in Graph with weight w in edges:
           if distance[u] + w < distance[v]:
               distance[v] := distance[u] + w
               predecessor[v] := u

   // Step 3: check for negative-weight cycles
   for each edge (u, v) in Graph with weight w in edges:
       if distance[u] + w < distance[v]:
           error "Graph contains a negative-weight cycle"
   return distance[], predecessor[]

如何测试加权图是否具有负周期

2 个答案: