public static FlowNetwork BuildComplexFlowNetwork() { Graph g = new Graph(); g.AddEdge("s", "a"); g.AddEdge("s", "b"); g.AddEdge("a", "c"); g.AddEdge("b", "a"); g.AddEdge("b", "c"); g.AddEdge("c", "d"); g.AddEdge("c", "t"); g.AddEdge("d", "b"); g.AddEdge("d", "t"); var dictC = new Dictionary <EdgeKey, int>(); dictC[g.GetEdge("s", "a").GetKey()] = 4; dictC[g.GetEdge("s", "b").GetKey()] = 8; dictC[g.GetEdge("a", "c").GetKey()] = 6; dictC[g.GetEdge("b", "a").GetKey()] = 3; dictC[g.GetEdge("b", "c").GetKey()] = 6; dictC[g.GetEdge("c", "d").GetKey()] = 3; dictC[g.GetEdge("c", "t").GetKey()] = 11; dictC[g.GetEdge("d", "b").GetKey()] = 1; dictC[g.GetEdge("d", "t").GetKey()] = 2; var c = FlowNetwork.DictToFlow(dictC); return(new FlowNetwork(g, c, "s", "t")); }
private bool HasAugmentingPath(FlowNetwork graph, int s, int t) { _edgeTo = new Dictionary <int, FlowEdge>(); _marked = new HashSet <int>(); var queue = new Queue <int>(); queue.Enqueue(s); _marked.Add(s); while (queue.Count > 0) { var v = queue.Dequeue(); foreach (var edge in graph.Adjacent(v)) { var w = edge.Other(v); if (edge.ResidualCapacityTo(w) > 0 && !_marked.Contains(w)) { _edgeTo.Add(w, edge); _marked.Add(w); queue.Enqueue(w); } } } return(_marked.Contains(t)); }
public virtual void SetGraph(FlowNetwork g) { graph = new FlowNetwork(g); graph.OnEdgeFlowChanged += (sender, edge) => OnEdgeFlowChanged?.Invoke(this, sender, edge); graph.OnEdgeMarked += (sender, edge) => OnEdgeMarked?.Invoke(this, sender, edge); graph.OnEdgeUnmarked += (sender, edge) => OnEdgeUnmarked?.Invoke(this, sender, edge); }
public void RedirectEdge(FlNwNodeVisualization _to_node, bool _rerout_start, FlowNetwork _owner) { if (_to_node == null || _owner == null) { return; } // perform redirection in the data FlNetEdge edge_data = this.FN_Edge; FlNetNode node_data = _to_node.FN_Node; bool success = false; if (edge_data != null && node_data != null) { success = _owner.RedirectEdge(edge_data, _rerout_start, node_data); } // perform redirection in the visualizations if (success) { if (_rerout_start) { this.StartVis = _to_node; } else { this.EndVis = _to_node; } } }
private static void TestResidualNetwork() { //Create graph from Figure 6.10 FlowNetwork fn = new FlowNetwork(); Vertex v1 = new Vertex(); Vertex v2 = new Vertex(); Vertex v3 = new Vertex(); Vertex v4 = new Vertex(); fn.AddVertex(v1); fn.AddVertex(v2); fn.AddVertex(v3); fn.AddVertex(v4); fn.SetSource(v1); fn.SetSink(v4); fn.AddEdge(new FlowEdge(v1, v3, 3, 4)); fn.AddEdge(new FlowEdge(v1, v2, 2, 2)); fn.AddEdge(new FlowEdge(v2, v3, 2, 3)); fn.AddEdge(new FlowEdge(v3, v4, 5, 5)); fn.AddEdge(new FlowEdge(v2, v4, 0, 1)); Graph g = GraphAlgorithms.CreateResidualNetwork(fn); }
private static void TestMaxFlow() { FlowNetwork fn = new FlowNetwork(); Vertex v1 = new Vertex(); Vertex v2 = new Vertex(); Vertex v3 = new Vertex(); Vertex v4 = new Vertex(); Vertex v5 = new Vertex(); Vertex v6 = new Vertex(); fn.AddVertex(v1); fn.AddVertex(v2); fn.AddVertex(v3); fn.AddVertex(v4); fn.AddVertex(v5); fn.AddVertex(v6); fn.SetSource(v1); fn.SetSink(v6); fn.AddEdge(new FlowEdge(v1, v2, 0f, 2f)); fn.AddEdge(new FlowEdge(v1, v3, 0f, 2f)); fn.AddEdge(new FlowEdge(v2, v4, 0f, 2f)); fn.AddEdge(new FlowEdge(v3, v4, 1f, 2f)); fn.AddEdge(new FlowEdge(v3, v5, 0f, 2f)); fn.AddEdge(new FlowEdge(v4, v6, 1f, 2f)); fn.AddEdge(new FlowEdge(v5, v6, 0f, 2f)); //float maxFlow = GraphAlgorithms.MaximumFlow(fn); //Console.WriteLine("Max flow is " + maxFlow); }
public FordFulkerson(FlowNetwork G, int s, int t) { Validate(s, G.V); Validate(t, G.V); if (s == t) { throw new ArgumentException("Source equals sink"); } if (!IsFeasible(G, s, t)) { throw new ArgumentException("Initial flow is infeasible"); } Value = Excess(G, t); while (HasAugmentingPath(G, s, t)) { var bottle = Double.PositiveInfinity; // compute bottleneck capacity; for (var v = t; v != s; v = _edgeTo[v].Other(v)) { bottle = Math.Min(bottle, _edgeTo[v].ResidualCapacityTo(v)); } // augment flow for (var v = t; v != s; v = _edgeTo[v].Other(v)) { _edgeTo[v].AddResidualFlowTo(v, bottle); } Value += bottle; } }
private void mnOpen_Click(object sender, EventArgs e) { if (dlgOpenFile.ShowDialog() == DialogResult.OK) { using (FileStream fs = new FileStream(dlgOpenFile.FileName, FileMode.Open)) { XmlDocument xml = new XmlDocument(); try { xml.Load(fs); FlowNetwork g = new FlowNetwork(); g.ParseXml(xml); Runtime.currentGraph = g; Visualizer.ZoomFit(pbDraw.ClientRectangle); Invalidate(); pbDraw.Invalidate(); } catch (Exception ex) { Log.Write("Can't load FlowNetwork from file.", Log.ERROR); Log.Write(ex.Message, Log.ERROR); } } } }
private bool HasAugmentingPath(FlowNetwork G, int s, int t) { _edgeTo = new FlowEdge[G.V]; _marked = new bool[G.V]; var queue = new Queue <int>(); queue.Enqueue(s); _marked[s] = true; while (queue.Count > 0 && !_marked[t]) { var v = queue.Dequeue(); foreach (var e in G.Adj(v)) { var w = e.Other(v); if (e.ResidualCapacityTo(w) > 0) { if (!_marked[w]) { _edgeTo[w] = e; _marked[w] = true; queue.Enqueue(w); } } } } return(_marked[t]); }
public void Test() { FlowNetwork network = GraphGenerator.flowNetwork(); FordFulkerson fordFulkerson = new FordFulkerson(network, 0, 7); console.WriteLine("max-flow: " + fordFulkerson.Value); Console.WriteLine("max-flow: " + fordFulkerson.Value); }
public FlowNetworkGraphWindow OpenNetworkGraphWindow(FlowNetwork _to_display, ComponentFactory _factory) { this.flow_nw_Gr_win = new FlowNetworkGraphWindow(); this.flow_nw_Gr_win.Network = _to_display; this.flow_nw_Gr_win.CompManager = _factory; this.flow_nw_Gr_win.Show(); return(this.flow_nw_Gr_win); }
private FlowNetwork FromFn(FileInfo file) { FlowNetwork g = new FlowNetwork(); int source = -1, target = -1; try { System.IO.StreamReader fs = new System.IO.StreamReader(file.FullName); string line; while ((line = fs.ReadLine()) != null) { if (line.StartsWith("SOURCE")) { var s = line.Split(':'); source = int.Parse(s[1]) - 1; } if (line.StartsWith("TARGET")) { var s = line.Split(':'); target = int.Parse(s[1]) - 1; } if (char.IsLetter(line[0])) { continue; } var d = line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); int n0 = int.Parse(d[0]) - 1; // My numbering starts with 0, not 1 if (n0 == -2) { break; } int n1 = int.Parse(d[1]) - 1; // My numbering starts with 0, not 1 int w = int.Parse(d[2]); // weight g.AddEdge(n0, n1, w); } } catch (Exception ex) { Log.Write(ex.Message, Log.ERROR); } g.Source = source; g.Target = target; var validation = g.Validate(); if (validation.Count > 0) { foreach (var error in validation) { Log.Write(error, Log.ERROR); } return(null); } return(g); }
private void onNewFlowNetwork(object sender, EventArgs e) { string graphName = "Graph " + graphCounter; FlowNetwork newGraph = app.NewFlowNetwork(graphName); newGraph.ShowEdgeLabels = true; makeNewGraphPanel(newGraph); }
private FlowNetwork FromDimac(FileInfo file) { FlowNetwork g = new FlowNetwork(); var srs = -1; var trg = -1; try { System.IO.StreamReader fs = new System.IO.StreamReader(file.FullName); string line; while ((line = fs.ReadLine()) != null) { if (line.EndsWith("s")) { var s = line.Split(' '); srs = int.Parse(s[1]) - 1; } if (line.EndsWith("t")) { var t = line.Split(' '); trg = int.Parse(t[1]) - 1; } if (line.StartsWith("a")) { var a = line.Split(' '); int from = int.Parse(a[1]) - 1; int to = int.Parse(a[2]) - 1; int weight = int.Parse(a[3]); g.AddEdge(from, to, weight); } } } catch (Exception ex) { Log.Write(ex.Message, Log.ERROR); } g.Source = srs; g.Target = trg; var validation = g.Validate(); if (validation.Count > 0) { foreach (var error in validation) { Log.Write(error, Log.ERROR); } return(null); } return(g); }
private FlowNetwork FromCSV(FileInfo file) { FlowNetwork g = new FlowNetwork(); int source = -1, target = -1; using (TextFieldParser parser = new TextFieldParser(file.FullName)) { parser.TextFieldType = FieldType.Delimited; parser.SetDelimiters(","); int line = 0; while (!parser.EndOfData) { string[] fields = parser.ReadFields(); line++; if (line == 1) { //skip header continue; } if (line == 2) { int.TryParse(fields[0], out source); int.TryParse(fields[1], out target); //parse source and target continue; } //Process row int from, to; double capacity; int.TryParse(fields[0], out from); int.TryParse(fields[1], out to); double.TryParse(fields[2], out capacity); g.AddEdge(from, to, capacity); } } g.Source = source; g.Target = target; var validation = g.Validate(); if (validation.Count > 0) { foreach (var error in validation) { Log.Write(error, Log.ERROR); } return(null); } return(g); }
public void TestDinitz() { FlowNetwork N = BuildSimpleFlowNetwork(); var f = N.Dinitz(); Assert.AreEqual(1, f(N.G.GetEdge("s", "a"))); Assert.AreEqual(1, f(N.G.GetEdge("s", "b"))); Assert.AreEqual(1, f(N.G.GetEdge("a", "t"))); Assert.AreEqual(1, f(N.G.GetEdge("b", "t"))); Assert.IsTrue(N.IsValidFlow(f)); N = BuildComplexFlowNetwork(); f = N.Dinitz(); Assert.AreEqual(12, f(N.G.GetEdge("s", "a")) + f(N.G.GetEdge("s", "b"))); Assert.AreEqual(12, f(N.G.GetEdge("c", "t")) + f(N.G.GetEdge("d", "t"))); Assert.IsTrue(N.IsValidFlow(f)); }
private double Excess(FlowNetwork G, int v) { var excess = 0.0; foreach (var e in G.Adj(v)) { if (v == e.From) { excess -= e.Flow; } else { excess += e.Flow; } } return(excess); }
private bool IsFeasible(FlowNetwork G, int s, int t) { for (var v = 0; v < G.V; v++) { foreach (var e in G.Adj(v)) { if (e.Flow < Double.Epsilon || e.Flow > e.Capacity + Double.Epsilon) { // Sytem.err.println("Edge does not satisfy capacity constraints: " + e); return(false); } } } if (Math.Abs(Value + Excess(G, s)) > Double.Epsilon) { // System.err.println("Excess at source = " + Excess(G, s)); // System.err.println("Mas flow = " + Value); return(false); } if (Math.Abs(Value - Excess(G, t)) > Double.Epsilon) { //System.err.println("Excess at sink = " + excess(G, t)); //System.err.println("Max flow = " + value); return(false); } for (int v = 0; v < G.V; v++) { if (v == s || v == t) { continue; } if (Math.Abs(Excess(G, v)) > Double.Epsilon) { //System.err.println("Net flow out of " + v + " doesn't equal zero"); return(false); } } return(true); }
private double DFS(ref FlowNetwork graph, ref List <FlowEdge> path, int[] ptr, int dest, int u, double f) { if (u == dest) { return(f); } for (; ptr[u] < graph.Nodes[u].OutcomingEdges.Count(); ++ptr[u]) { FlowEdge e = graph.Nodes[u].OutcomingEdges[ptr[u]]; if (e.Flow < e.Capacity) { double df = DFS(ref graph, ref path, ptr, dest, e.To, Math.Min(f, e.Capacity - e.Flow)); if (df > 0) { path.Add(e); return(df); } } } return(0); }
public FordFulkerson(FlowNetwork graph, int s, int t) { Value = 0; while (HasAugmentingPath(graph, s, t)) { var bottle = double.PositiveInfinity; for (var v = t; v != s; v = _edgeTo[v].Other(v)) { bottle = Math.Min(bottle, _edgeTo[v].ResidualCapacityTo(v)); } for (var v = t; v != s; v = _edgeTo[v].Other(v)) { _edgeTo[v].AddResidualFlowTo(v, bottle); } Value += bottle; } }
public static FlowNetwork flowNetwork() { FlowNetwork g = new FlowNetwork(8); g.addEdge(new FlowEdge(0, 1, 10)); g.addEdge(new FlowEdge(0, 2, 5)); g.addEdge(new FlowEdge(0, 3, 15)); g.addEdge(new FlowEdge(1, 4, 9)); g.addEdge(new FlowEdge(1, 5, 15)); g.addEdge(new FlowEdge(1, 2, 4)); g.addEdge(new FlowEdge(2, 5, 8)); g.addEdge(new FlowEdge(2, 3, 4)); g.addEdge(new FlowEdge(3, 6, 16)); g.addEdge(new FlowEdge(4, 5, 15)); g.addEdge(new FlowEdge(4, 7, 10)); g.addEdge(new FlowEdge(5, 7, 10)); g.addEdge(new FlowEdge(5, 6, 15)); g.addEdge(new FlowEdge(6, 2, 6)); g.addEdge(new FlowEdge(6, 7, 10)); return(g); }
public override DataTemplate SelectTemplate(object item, DependencyObject container) { if (container == null) { return(null); } FrameworkElement element = container as FrameworkElement; if (element == null) { return(null); } if (item == null) { return(element.TryFindResource("DT_Empty") as DataTemplate); } FlNetNode node = item as FlNetNode; FlNetEdge edge = item as FlNetEdge; FlowNetwork network = item as FlowNetwork; if (node != null && network == null) { return(element.TryFindResource("FlNetNodeInList") as DataTemplate); } else if (edge != null) { return(element.TryFindResource("FlNetEdgeInList") as DataTemplate); } else if (network != null) { return(element.TryFindResource("NetworkInList") as DataTemplate); } else { return(null); } }
private void onMaxFlow(object sender, EventArgs e) { if (CurrentGraphPanel == null) { return; } //Make sure one vertex is selected List <ISelectable> selection = CurrentGraphPanel.GetSelection(); GUIVertex source, sink; if (selection.Count != 2) { Output.WriteLine("Please select both the source and the sink, in that order"); return; } else if (selection[0] as GUIVertex == null || selection[1] as GUIVertex == null) { Output.WriteLine("Please select both the source and the sink, in that order"); return; } else { source = selection[0] as GUIVertex; sink = selection[1] as GUIVertex; } List <GUIVertex> verts = CurrentGraphPanel.Vertices; FlowNetwork fn = CurrentGraphPanel.Graph as FlowNetwork; if (fn != null) { float max = GraphAlgorithms.MaximumFlow(fn, fn.GetVertices().IndexOf(source.Vertex), fn.GetVertices().IndexOf(sink.Vertex)); Output.WriteLine("[Max Flow Output]"); Output.WriteLine("Max flow is " + max); Output.WriteLine("[End Max Flow Output]"); } }
/**//**/ public static void main(string[] strarr) { int num = Integer.parseInt(strarr[0]); int num2 = Integer.parseInt(strarr[1]); int i = 2 * num; int i2 = 2 * num + 1; FlowNetwork flowNetwork = new FlowNetwork(2 * num + 2); for (int j = 0; j < num2; j++) { int k = StdRandom.uniform(num); int num3 = StdRandom.uniform(num) + num; flowNetwork.addEdge(new FlowEdge(k, num3, double.PositiveInfinity)); StdOut.println(new StringBuilder().append(k).append("-").append(num3).toString()); } for (int j = 0; j < num; j++) { flowNetwork.addEdge(new FlowEdge(i, j, (double)1f)); flowNetwork.addEdge(new FlowEdge(j + num, i2, (double)1f)); } FordFulkerson fordFulkerson = new FordFulkerson(flowNetwork, i, i2); StdOut.println(); StdOut.println(new StringBuilder().append("Size of maximum matching = ").append(ByteCodeHelper.d2i(fordFulkerson.value())).toString()); for (int k = 0; k < num; k++) { Iterator iterator = flowNetwork.adj(k).iterator(); while (iterator.hasNext()) { FlowEdge flowEdge = (FlowEdge)iterator.next(); if (flowEdge.from() == k && flowEdge.flow() > (double)0f) { StdOut.println(new StringBuilder().append(flowEdge.from()).append("-").append(flowEdge.to()).toString()); } } } }
// assumes that _fn_nw is not NULL public FlNwNetworkVisualization(FlowNwGraph _parent, FlowNetwork _fn_nw, NodePosInFlow _pos_in_flow) : base(_parent, _fn_nw, _pos_in_flow) { this.fn_nw = _fn_nw; }
private void ExtendFlow(ref FlowNetwork A, List <List <int> > scc, double flow, List <FlowEdge> path) { var supernodes = new List <int>(); foreach (var contracted in scc.Where((list) => list.Count() > 1)) { supernodes.Add(contracted.First()); } var excess = new Dictionary <int, double>(); //flow balance foreach (var node in graph.Nodes.Keys) { excess.Add(node, 0); } excess[graph.Source] = flow; //should be 0 at the end of routing flow excess[graph.Target] = -flow; //should be 0 at the end of routing flow foreach (var edge in path) { if (!supernodes.Contains(edge.From) && !supernodes.Contains(edge.To)) { graph.PushFlow(edge.From, edge.To, flow); excess[edge.From] -= flow; excess[edge.To] += flow; } } //reroute flow in strongly connected components using excess lables //working with original graph foreach (var contracted in scc.Where((list) => list.Count() > 1)) { foreach (var node in contracted) //routing edges in and out of supernodes { foreach (var edge in graph.Nodes[node].IncomingEdges) { if (excess[edge.From] > 0 && !contracted.Contains(edge.From)) { var f = Math.Min(edge.ResidualCapacityTo(node), excess[edge.From]); edge.AddFlow(f, node); excess[edge.From] -= f; excess[node] += f; } } foreach (var edge in graph.Nodes[node].OutcomingEdges) { if (excess[edge.To] < 0 && !contracted.Contains(edge.To)) { var f = Math.Min(edge.ResidualCapacityTo(edge.To), -excess[edge.To]); edge.AddFlow(f, edge.To); excess[node] -= f; excess[edge.To] += f; } } } while (contracted.Count((id) => excess[id] > 0) > 0)//multiple source { int srs = contracted.First((id) => excess[id] > 0); while (excess[srs] > 0 && contracted.Count((id) => excess[id] < 0) > 0) //multiple target { int trg = contracted.First((id) => excess[id] < 0); SimpleBlockingFlowInConnectedComponent(contracted, ref excess, srs, trg); } } } }
private FlowNetwork ContractZeroLengthSCC(out List <List <int> > scc) { int[] ids = new int[graph.NodeCount]; int[] lowLinks = new int[graph.NodeCount]; var admissible_edges = new List <FlowEdge>(); foreach (var edge in graph.Edges) { if (dist[edge.From] == dist[edge.To] + BinaryLength(edge))//length[edge]) //admissible edge { admissible_edges.Add(edge); } } scc = new List <List <int> >(); var stack = new Stack <int>(); var sorted_nodes = TopologicalSort(admissible_edges); // поиск сильно связанных компонентов int id = 0; foreach (var node in sorted_nodes) { if (ids[node] == 0) { SCC(node, id, ref stack, ref scc, ref ids, ref lowLinks); } } // устанавливаем пропускные способности ребер связанных компонентов var contracted_admissible_edges = new List <FlowEdge>(); foreach (var edge in admissible_edges) { string res = "00"; foreach (var contracted in scc.Where((list) => list.Count() > 1)) { res = $"{(contracted.Contains(edge.From) ? 1 : 0)}{(contracted.Contains(edge.To) ? 1 : 0)}"; switch (res) { //case "00": contracted_admissible_edges.Add(edge); break; case "01": var e = new FlowEdge(edge.From, contracted.First(), edge.ResidualCapacityTo(edge.To)); var idx = contracted_admissible_edges.IndexOf(e); if (idx == -1) { contracted_admissible_edges.Add(e); } else { contracted_admissible_edges[idx].Capacity += edge.ResidualCapacityTo(edge.To); } break; case "10": e = new FlowEdge(contracted.First(), edge.To, edge.ResidualCapacityTo(edge.To)); idx = contracted_admissible_edges.IndexOf(e); if (idx == -1) { contracted_admissible_edges.Add(e); } else { contracted_admissible_edges[idx].Capacity += edge.ResidualCapacityTo(edge.To); } break; } } if (String.Equals(res, "00")) { contracted_admissible_edges.Add(new FlowEdge(edge)); } } // создаем граф var contracted_graph = new FlowNetwork(contracted_admissible_edges); contracted_graph.Source = graph.Source; contracted_graph.Target = graph.Target; return(contracted_graph); }
void CriarNodos() { List <string> arquivoLido = new List <string>(LerAqruivo().Split(default(string[]), StringSplitOptions.RemoveEmptyEntries)); List <int> numerosLidos = new List <int>(); for (int i = 0; i < arquivoLido.Count; i++) { numerosLidos.Add(Int32.Parse(arquivoLido[i])); } for (int i = 0; i < numerosLidos.Count; i = i + 3) { //print(numerosLidos[i]); bool novo; GameObject nodo; if (GameObject.Find("Nodo " + numerosLidos[i].ToString()) == null) { nodo = Instantiate(nodoPrefab, transform.position, Quaternion.identity, transform); novo = true; } else { nodo = GameObject.Find("Nodo " + numerosLidos[i].ToString()); novo = false; } Nodo nodoScript = nodo.GetComponent <Nodo>(); nodoScript.numero = numerosLidos[i]; nodoScript.gameObject.name = "Nodo " + numerosLidos[i].ToString(); Conexao conexao = Instantiate(conexaoPrefab); conexao.transform.SetParent(nodo.transform); conexao.origem = numerosLidos[i]; conexao.destino = numerosLidos[i + 1]; conexao.custo = numerosLidos[i + 2]; nodoScript.conexoes.Add(conexao); if (novo) { nodos.Add(nodoScript); } } print("numero de nodos na lista: " + nodos.Count); int numeroDeConexoes = 0; foreach (Nodo nodo in nodos) { foreach (Conexao conexao in nodo.conexoes) { numeroDeConexoes++; } } print(numeroDeConexoes); FlowNetwork flowNetwork = new FlowNetwork(numeroDeConexoes); foreach (Nodo nodo in nodos) { foreach (Conexao conexao in nodo.conexoes) { flowNetwork.AddEdge(new FlowEdge(nodo.numero, conexao.destino, conexao.custo)); } } FordFulkerson fordFulkerson = new FordFulkerson(flowNetwork, 1, 99); print(fordFulkerson.Value); }
public void EdgeFlowChanged(BaseMaxFlowAlgorithm algorithm, FlowNetwork network, FlowEdge edge) { AddAnimation(new Animation(edge, AnimationType.EdgeFlowChanged)); }