Обновление графика в Форд-Фулкерсон
Я использую алгоритм Форда-Фулкерсона, но у меня возникли проблемы с обновлением графика после фазы увеличения. Моя структура данных не делает это легким, я думаю.
Для представления графика я использую это:
private Map<Vertex, ArrayList<Edge>> outgoingEdges;
То есть я связываю в каждой вершине свой список исходящих ребер.
Чтобы управлять обратными краями, я связал "противоположный" край для каждого края в графе.
Любое предложение приветствуется.
public class FF {
/**
* Associates each Vertex with his list of outgoing edges
*/
private Map<Vertex, ArrayList<Edge>> outgoingEdges;
public FF() {
outgoingEdges = new HashMap<Vertex, ArrayList<Edge>>();
}
/**
* Returns the nodes of the graph
*/
public Collection<Vertex> getNodes() {
return outgoingEdges.keySet();
}
/**
* Returns the outgoing edges of a node
*/
public Collection<Edge> getIncidentEdges(Vertex v) {
return outgoingEdges.get(v);
}
/**
* Adds a new edge to the graph
*/
public void insertEdge(Vertex source, Vertex destination, float capacity) throws Exception {
if (!(outgoingEdges.containsKey(source) && outgoingEdges.containsKey(destination)))
throw new Exception("Unable to add the edge");
Edge e = new Edge(source, destination, capacity);
Edge opposite = new Edge(destination, source, capacity);
outgoingEdges.get(source).add(e);
outgoingEdges.get(destination).add(opposite);
e.setOpposite(opposite);
opposite.setOpposite(e);
}
/**
* Adds a new node to the graph
*/
public void insertNode(Vertex v) {
if (!outgoingEdges.containsKey(v))
outgoingEdges.put(v, new ArrayList<Edge>());
}
/**
* Ford-Fulkerson algorithm
*
* @return max flow
*/
public int fordFulkerson(Vertex source, Vertex destination) {
List<Edge> path = new ArrayList<Edge>();
int maxFlow = 0;
while(bfs(source, destination, path)) {
// finds the bottleneck
float minCap = bottleneck(path);
// updates the maxFlow
maxFlow += minCap;
// updates the graph <-- this updates only the local list path, not the graph!
for(Edge e : path) {
try {
e.addFlow(minCap);
e.getOpposite().addFlow(-minCap);
} catch (Exception e1) {
e1.printStackTrace();
}
}
path.clear();
}
return maxFlow;
}
/**
* @param Path of which we have to find the bottleneck
* @return bottleneck of the path
*/
private float bottleneck(List<Edge> path) {
float min = Integer.MAX_VALUE;
for(Edge e : path) {
float capacity = e.getCapacity();
if(capacity <= min) {
min = capacity;
}
}
return min;
}
/**
* BFS to obtain a path from the source to the destination
*
* @param source
* @param destination
* @param path
* @return
*/
private boolean bfs(Vertex source, Vertex destination, List<Edge> path) {
Queue<Vertex> queue = new LinkedList<Vertex>();
List<Vertex> visited = new ArrayList<Vertex>(); // list of visited vertexes
queue.add(source);
//source.setVisited(true);
visited.add(source);
while(!queue.isEmpty()) {
Vertex d = queue.remove();
if(!d.equals(destination)) {
ArrayList<Edge> d_outgoingEdges = outgoingEdges.get(d);
for(Edge e : d_outgoingEdges) {
if(e.getCapacity() - e.getFlow() > 0) { // there is still available flow
Vertex u = e.getDestination();
if(!visited.contains(u)) {
//u.setVisited(true);
visited.add(u);
queue.add(u);
path.add(e);
}
}
}
}
}
if(visited.contains(destination)) {
return true;
}
return false;
}
}
край
public class Edge {
private Vertex source;
private Vertex destination;
private float flow;
private final float capacity;
private Edge opposite;
public Edge(Vertex source, Vertex destination, float capacity) {
this.source = source;
this.destination = destination;
this.capacity = capacity;
}
public Edge getOpposite() {
return opposite;
}
public void setOpposite(Edge e) {
opposite = e;
}
public void setSource(Vertex v) {
source = v;
}
public void setDestination(Vertex v) {
destination = v;
}
public void addFlow(float f) throws Exception {
if(flow == capacity) {
throw new Exception("Unable to add flow");
}
flow += f;
}
public Vertex getSource() {
return source;
}
public Vertex getDestination() {
return destination;
}
public float getFlow() {
return flow;
}
public float getCapacity() {
return capacity;
}
public boolean equals(Object o) {
Edge e = (Edge)o;
return e.getSource().equals(this.getSource()) && e.getDestination().equals(this.getDestination());
}
}
темя
public class Vertex {
private String label;
public Vertex(String label) {
this.label = label;
}
public boolean isVisited() {
return visited;
}
public String getLabel() {
return label;
}
public boolean equals(Object o) {
Vertex v = (Vertex)o;
return v.getLabel().equals(this.getLabel());
}
}
1 ответ
Хотя, строго говоря, вопрос можно рассматривать как "не по теме" (поскольку вы в основном ищете помощь в отладке), это один из ваших первых вопросов, поэтому некоторые общие советы:
Когда вы размещаете здесь вопрос, учитывайте, что люди здесь добровольцы. Сделайте так, чтобы им было легко ответить на вопрос. В данном конкретном случае: вы должны создать MCVE, чтобы люди могли быстро скопировать и вставить ваш код (предпочтительно в одном блоке кода) и запустить программу без каких-либо усилий. Например, вы должны включить тестовый класс, включающий main метод, как этот:
public class FFTest
{
/**
* B---D
* / \ / \
* A . F
* \ / \ /
* C---E
*/
public static void main(String[] args) throws Exception
{
FF ff = new FF();
Vertex vA = new Vertex("A");
Vertex vB = new Vertex("B");
Vertex vC = new Vertex("C");
Vertex vD = new Vertex("D");
Vertex vE = new Vertex("E");
Vertex vF = new Vertex("F");
ff.insertNode(vA);
ff.insertNode(vB);
ff.insertNode(vC);
ff.insertNode(vD);
ff.insertNode(vE);
ff.insertNode(vF);
ff.insertEdge(vA, vB, 3.0f);
ff.insertEdge(vA, vC, 2.0f);
ff.insertEdge(vB, vD, 1.0f);
ff.insertEdge(vB, vE, 4.0f);
ff.insertEdge(vC, vD, 2.0f);
ff.insertEdge(vC, vE, 1.0f);
ff.insertEdge(vD, vF, 2.0f);
ff.insertEdge(vE, vF, 1.0f);
float result = ff.fordFulkerson(vA, vF);
System.out.println(result);
}
}
(Во всяком случае, вы должны были создать такой тестовый класс, когда пишете вопрос!)
Вы должны четко заявить, что вы НЕ используете Stackru в качестве "машины для решения магических проблем". В этом случае: я уже упоминал, что вы должны включить выходные данные отладки. Если бы вы продлили FF класс с такими методами....
private static void printPath(List<Edge> path)
{
System.out.println("Path: ");
for (int i=0; i<path.size(); i++)
{
Edge e = path.get(i);
System.out.println(
"Edge "+e+
" flow "+e.getFlow()+
" cap "+e.getCapacity());
}
}
который может быть вызван в основном цикле следующим образом:
while(bfs(source, destination, path)) {
...
System.out.println("Before updating with "+minCap);
printPath(path);
// updates the maxFlow
....
System.out.println("After updating with "+minCap);
printPath(path);
...
}
тогда вы бы уже заметили главную проблему с вашим кодом: ...
bfs метод неправильный! Вы неправильно восстанавливаете путь, который привел вас к вершине назначения. Вместо этого вы добавляете каждую посещаемую вершину к пути. Вы должны отследить, какое ребро использовалось для достижения определенного узла, а когда вы достигли вершины назначения, нужно идти назад.
Быстрый и грязный подход может выглядеть примерно (!) Следующим образом:
private boolean bfs(Vertex source, Vertex destination, List<Edge> path) {
Queue<Vertex> queue = new LinkedList<Vertex>();
List<Vertex> visited = new ArrayList<Vertex>(); // list of visited vertexes
queue.add(source);
visited.add(source);
Map<Vertex, Edge> predecessorEdges = new HashMap<Vertex, Edge>();
while(!queue.isEmpty()) {
Vertex d = queue.remove();
if(!d.equals(destination)) {
ArrayList<Edge> d_outgoingEdges = outgoingEdges.get(d);
for(Edge e : d_outgoingEdges) {
if(e.getCapacity() - e.getFlow() > 0) { // there is still available flow
Vertex u = e.getDestination();
if(!visited.contains(u)) {
visited.add(u);
queue.add(u);
predecessorEdges.put(u, e);
}
}
}
}
else
{
constructPath(destination, predecessorEdges, path);
return true;
}
}
return false;
}
private void constructPath(Vertex destination,
Map<Vertex, Edge> predecessorEdges, List<Edge> path)
{
Vertex v = destination;
while (true)
{
Edge e = predecessorEdges.get(v);
if (e == null)
{
return;
}
path.add(0, e);
v = e.getSource();
}
}
(Вы всегда должны тестировать такой центральный метод независимо. Вы могли бы легко создать небольшую тестовую программу, которая вычисляет несколько путей, и вы быстро заметили бы, что эти пути неверны - и, следовательно, что Ford Fulkerson не может работать должным образом все).
Дальнейшие замечания:
Всякий раз, когда вы отменяете equals метод, вы также должны переопределить hashCode метод. Некоторые правила применяются здесь, вы должны обязательно обратиться к документации Object#equalsа также Object#hashCode,
Часто полезно дополнительно переопределить toString метод, так что вы можете легко распечатать объекты на консоли.
В вашем случае эти методы могут быть реализованы так, для Vertex
@Override
public int hashCode()
{
return getLabel().hashCode();
}
@Override
public boolean equals(Object o) {
Vertex v = (Vertex)o;
return v.getLabel().equals(this.getLabel());
}
@Override
public String toString()
{
return getLabel();
}
И для Edge
@Override
public String toString()
{
return "("+getSource()+","+getDestination()+")";
}
@Override
public int hashCode()
{
return source.hashCode() ^ destination.hashCode();
}
@Override
public boolean equals(Object o) {
Edge e = (Edge)o;
return e.getSource().equals(this.getSource()) &&
e.getDestination().equals(this.getDestination());
}
Емкости краев float значения, поэтому результирующий поток также должен быть float значение.
С упомянутыми выше изменениями программа запускается и печатает "правдоподобный" результат. Я НЕ проверил это на правильность. Но это ваша задача, и теперь это должно быть намного проще.
PS: нет, Соно Тедеско.