public static long getMaxFlow(this MyGraph myGraph) { long totalFlow; var pipes = myGraph.Pipes; var nodes = myGraph.Nodes; int numNodes = nodes.Count(); int numPipes = pipes.Count(); char startingPoint = Char.Parse(myGraph.getStartingPoint()); char endPoint = Char.Parse(myGraph.getEndPoint()); List <int> tails, heads, capacities; tails = new List <int>(); heads = new List <int>(); capacities = new List <int>(); foreach (var node in nodes) { foreach (var pipe in node.Pipes) { if (pipe.StartingValue > 0) { tails.Add(Char.Parse(pipe.StartingPoint) - 'A'); heads.Add(Char.Parse(pipe.EndPoint) - 'A'); capacities.Add(pipe.StartingValue); } } } MaxFlow maxFlow = new MaxFlow(); for (int i = 0; i < tails.Count(); ++i) { int arc = maxFlow.AddArcWithCapacity(tails[i], heads[i], capacities[i]); if (arc != i) { throw new Exception("Internal error"); } } int source = startingPoint - 'A'; int sink = endPoint - 'A'; Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " + numPipes + " arcs, source=" + source + ", sink=" + sink); MaxFlow.Status solveStatus = maxFlow.Solve(source, sink); if (solveStatus == MaxFlow.Status.OPTIMAL) { totalFlow = maxFlow.OptimalFlow(); } else { Console.WriteLine("Solving the max flow problem failed. Solver status: " + solveStatus); totalFlow = 0; } return(totalFlow); }
public void Solve() { var n = ri; var a = Enumerate(n, x => rl); var mf = new MaxFlow(2 * n + 2); var src = 2 * n; var sink = src + 1; var ans = 0L; for (int i = 1; i <= n; i++) { var v = a[i - 1]; if (v < 0) { //??????? mf.AddDirectedEdge(n + i - 1, sink, -v); } else { ans += v; //????? mf.AddDirectedEdge(src, i - 1, v); } mf.AddDirectedEdge(i - 1, i + n - 1, INF); for (int j = 2 * i; j <= n; j += i) { // j ??????i ????????? mf.AddDirectedEdge(j - 1, i - 1 + n, INF); } } var val = mf.Execute(src, sink); Debug.WriteLine(val); Console.WriteLine(ans - val); }
public static void GetFlow(List <Nodes> node, int[,] matrix, int rootNode) { foreach (Nodes thisNode in node) { thisNode.flow = MaxFlow.fordFulkerson(matrix, rootNode, thisNode.index, matrix.GetLength(0)); } }
public static void Main(string[] args) { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; int CASES = int.Parse(Console.ReadLine()); for (int CASE = 1; CASE <= CASES; CASE++) { Console.Error.WriteLine("Case " + CASE); int n = int.Parse(Console.ReadLine()); string[][] ws = new string[n][]; for (int i = 0; i < n; i++) { ws[i] = Console.ReadLine().Split(); } Dictionary <string, int> count1 = new Dictionary <string, int>(); Dictionary <string, int> count2 = new Dictionary <string, int>(); for (int i = 0; i < n; i++) { if (count1.ContainsKey(ws[i][0])) { count1[ws[i][0]]++; } else { count1[ws[i][0]] = 1; } if (count2.ContainsKey(ws[i][1])) { count2[ws[i][1]]++; } else { count2[ws[i][1]] = 1; } } string[] firsts = count1.Keys.ToArray(); string[] seconds = count2.Keys.ToArray(); MaxFlow mf = new MaxFlow(n * 2); for (int i = 0; i < firsts.Length; i++) { mf.Add(mf.Source, i, count1[firsts[i]] - 1); } for (int i = 0; i < seconds.Length; i++) { mf.Add(n + i, mf.Sink, count2[seconds[i]] - 1); } for (int i = 0; i < n; i++) { mf.Add(Array.IndexOf(firsts, ws[i][0]), n + Array.IndexOf(seconds, ws[i][1]), 1); } Console.WriteLine("Case #" + CASE + ": " + mf.NetworkFlow()); } }
public void Solve() { int N = NextInt(); var Alist = new List <ti3>(); var Blist = new List <ti3>(); var s = 0; var t = 2 * N + 1; var mf = new MaxFlow(t + 1); N.REP(i => { var ai = NextInt(); var bi = NextInt(); Alist.Add(new ti3(ai, bi, i + 1)); mf.Add(s, i + 1, 1); }); N.REP(i => { var ai = NextInt(); var bi = NextInt(); Alist.Add(new ti3(ai, bi, i + N + 1)); mf.Add(i + N + 1, t, 1); }); var list = Alist.Concat(Blist).OrderBy(x => x.Item1).Select(item => new ti2(item.Item2, item.Item3)).ToList(); for (int i = 0; i < list.Count; i++) { var a = list[i].Item2; if (a > N) { continue; } var ay = list[i].Item1; for (int j = i + 1; j < list.Count; j++) { var b = list[j].Item2; if (b < N + 1) { continue; } var by = list[j].Item1; if (by < ay) { continue; } mf.Add(a, b, 1); } } mf.Run(s, t).WL(); return; }
public void EdmondsKarpTest() { var data = CreateMaxFlowData(); var maxFlowTool = new MaxFlow <string>(); var maxFlow = maxFlowTool.EdmondsKarp(data.Item1, data.Item2, data.Item3); Assert.AreEqual(5, maxFlow); }
static void Main() { // [START data] // Define three parallel arrays: start_nodes, end_nodes, and the capacities // between each pair. For instance, the arc from node 0 to node 1 has a // capacity of 20. // From Taha's 'Introduction to Operations Research', // example 6.4-2. int[] startNodes = { 0, 0, 0, 1, 1, 2, 2, 3, 3 }; int[] endNodes = { 1, 2, 3, 2, 4, 3, 4, 2, 4 }; int[] capacities = { 20, 30, 10, 40, 30, 10, 20, 5, 20 }; // [END data] // [START constraints] // Instantiate a SimpleMaxFlow solver. MaxFlow maxFlow = new MaxFlow(); // Add each arc. for (int i = 0; i < startNodes.Length; ++i) { int arc = maxFlow.AddArcWithCapacity(startNodes[i], endNodes[i], capacities[i]); if (arc != i) { throw new Exception("Internal error"); } } // [END constraints] // [START solve] // Find the maximum flow between node 0 and node 4. int solveStatus = maxFlow.Solve(0, 4); // [END solve] // [START print_solution] if (solveStatus == MaxFlow.OPTIMAL) { Console.WriteLine("Max. flow: " + maxFlow.OptimalFlow()); Console.WriteLine(""); Console.WriteLine(" Arc Flow / Capacity"); for (int i = 0; i < maxFlow.NumArcs(); ++i) { Console.WriteLine(maxFlow.Tail(i) + " -> " + maxFlow.Head(i) + " " + string.Format("{0,3}", maxFlow.Flow(i)) + " / " + string.Format("{0,3}", maxFlow.Capacity(i))); } } else { Console.WriteLine("Solving the max flow problem failed. Solver status: " + solveStatus); } // [END print_solution] }
static void Main() { var h = Read(); int nx = h[0], ny = h[1]; var es = Array.ConvertAll(new bool[h[2]], _ => Read()); var r = MaxFlow.BipartiteMatching(nx, ny, es); Console.WriteLine(r.Length); }
/// <summary> /// Evaluates the similarity between two maps using the graph sampling evaluation of biagioni and eriksson. /// Parameters are hardcoded, based on the ones we used in the corresponding research. /// </summary> /// <param name="GT">The ground truth map</param> /// <param name="CT">the constructed map.</param> /// <param name="amount">the amount of neighbourhood evaluations we average over</param> /// <returns>A precision and recall value indicating the similarity between the maps.</returns> public (float, float) EvalMap(Map GT, Map CT, int amount) { float precision = 0; float recall = 0; for (int k = 0; k < amount; k++) { Coordinate originGT = rand.GetRandomPointOnRoad(rand.GetWeightedRandomRoad(GT)); Coordinate originCT = CT.GetClosestPoint(originGT.location); /* An extra step that is sometimes used in the literature when ground truth map is not pruned. * while (Vector3.Distance(originCT.location, originGT.location) > 50) * { * originGT = rand.GetRandomCoordinate(rand.GetWeightedRandomRoad(GT)); * originCT = CT.GetClosestPoint(originGT.location); * } */ List <Vector3> pointsGT = sampleNeighbourhood.GetNeighbourhood(GT, originGT, 500, 30); List <Vector3> pointsCT = sampleNeighbourhood.GetNeighbourhood(CT, originCT, 500, 30); MaxFlow flow = new MaxFlow(pointsGT.Count + pointsCT.Count + 2); for (int i = 0; i < pointsCT.Count; i++) { flow.AddEdge(0, i + 1, 1); } for (int i = 0; i < pointsCT.Count; i++) { Vector3 pointCT = pointsCT[i]; for (int j = 0; j < pointsGT.Count; j++) { Vector3 pointGT = pointsGT[j]; if (Vector3.Distance(pointCT, pointGT) < 20) { flow.AddEdge(i + 1, j + pointsCT.Count + 1, 1); } } } for (int i = 0; i < pointsGT.Count; i++) { flow.AddEdge(i + pointsCT.Count + 1, 1 + pointsCT.Count + pointsGT.Count, 1); } float matching = flow.FindMaximumFlow(0, 1 + pointsCT.Count + pointsGT.Count).Item1; precision += pointsCT.Count > 0 ? matching / pointsCT.Count : 0; recall += pointsGT.Count > 0 ? matching / pointsGT.Count : 0; } return(precision / amount, recall / amount); }
static void Main() { var h = Read(); var n = h[0]; var es = Array.ConvertAll(new bool[h[1]], _ => Read()); var mf = new MaxFlow(n); mf.AddEdges(es); Console.WriteLine(mf.Dinic(0, n - 1)); }
void Calc() { int N = re.i(); int[] A = new int[N]; int[] B = new int[N]; int[] C = new int[N]; int[] D = new int[N]; for (int i = 0; i < N; i++) { A[i] = re.i(); B[i] = re.i(); } for (int i = 0; i < N; i++) { C[i] = re.i(); D[i] = re.i(); } List <int> f = new List <int>(); List <int> t = new List <int>(); List <long> capa = new List <long>(); int S = 2 * N; int G = 2 * N + 1; for (int i = 0; i < N; i++) { f.Add(S); t.Add(i); capa.Add(1); } for (int i = 0; i < N; i++) { f.Add(i + N); t.Add(G); capa.Add(1); } for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (A[i] < C[j] && B[i] < D[j]) { f.Add(i); t.Add(j + N); capa.Add(1); } } } MaxFlow F = new MaxFlow(f.ToArray(), t.ToArray(), capa.ToArray(), 2 * N + 2, S, G); long count = F.flow; sb.Append(count + "\n"); }
// Driver code public static void Main() { // Let us create a graph shown in the above example int[,] graph = new int[, ] { { 0, 16, 13, 0, 0, 0 }, { 0, 0, 10, 12, 0, 0 }, { 0, 4, 0, 0, 14, 0 }, { 0, 0, 9, 0, 0, 20 }, { 0, 0, 0, 7, 0, 4 }, { 0, 0, 0, 0, 0, 0 } }; MaxFlow m = new MaxFlow(); Console.WriteLine("The maximum possible flow is " + m.fordFulkerson(graph, 0, 5)); }
/// <summary> /// Visualizes and evaluates a single random neighbourhood. /// </summary> /// <param name="GT">Ground truth map</param> /// <param name="CT">contructed map</param> /// <param name="originDistanceCondition"></param> /// <param name="matchDistance"></param> /// <returns></returns> public (float, float) EvalNeighbourhood(Map GT, Map CT) { Coordinate originGT = rand.GetRandomPointOnRoad(rand.GetWeightedRandomRoad(GT)); Coordinate originCT = CT.GetClosestPoint(originGT.location); /* An extra step that is sometimes used in the literature when ground truth map is not pruned. * while (Vector3.Distance(originCT.location, originGT.location) > 50) * { * originGT = rand.GetRandomCoordinate(rand.GetWeightedRandomRoad(GT)); * originCT = CT.GetClosestPoint(originGT.location); * } */ List <Vector3> pointsGT = sampleNeighbourhood.GetNeighbourhood(GT, originGT, 150, 30); List <Vector3> pointsCT = sampleNeighbourhood.GetNeighbourhood(CT, originCT, 150, 30); MaxFlow flow = new MaxFlow(pointsGT.Count + pointsCT.Count + 2); for (int i = 0; i < pointsCT.Count; i++) { flow.AddEdge(0, i + 1, 1); // source edges } for (int i = 0; i < pointsCT.Count; i++) // edges between CT and GT { Vector3 pointCT = pointsCT[i]; for (int j = 0; j < pointsGT.Count; j++) { Vector3 pointGT = pointsGT[j]; if (Vector3.Distance(pointCT, pointGT) < 20) { flow.AddEdge(i + 1, j + pointsCT.Count + 1, 1); } } } for (int i = 0; i < pointsGT.Count; i++) { flow.AddEdge(i + pointsCT.Count + 1, 1 + pointsCT.Count + pointsGT.Count, 1); // sink edges } float matching; int[,] graph; (matching, graph) = flow.FindMaximumFlow(0, 1 + pointsCT.Count + pointsGT.Count); float prec = pointsCT.Count > 0 ? matching / pointsCT.Count : 0; float recall = pointsGT.Count > 0 ? matching / pointsGT.Count : 0; return(prec, recall); }
private static void SolveMaxFlow() { Console.WriteLine("Max Flow Problem"); int numNodes = 6; int numArcs = 9; int[] tails = { 0, 0, 0, 0, 1, 2, 3, 3, 4 }; int[] heads = { 1, 2, 3, 4, 3, 4, 4, 5, 5 }; int[] capacities = { 5, 8, 5, 3, 4, 5, 6, 6, 4 }; int[] expectedFlows = { 4, 4, 2, 0, 4, 4, 0, 6, 4 }; int expectedTotalFlow = 10; MaxFlow maxFlow = new MaxFlow(); for (int i = 0; i < numArcs; ++i) { int arc = maxFlow.AddArcWithCapacity(tails[i], heads[i], capacities[i]); if (arc != i) { throw new Exception("Internal error"); } } int source = 0; int sink = numNodes - 1; Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " + numArcs + " arcs, source=" + source + ", sink=" + sink); int solveStatus = maxFlow.Solve(source, sink); if (solveStatus == MaxFlow.OPTIMAL) { long totalFlow = maxFlow.OptimalFlow(); Console.WriteLine("total computed flow " + totalFlow + ", expected = " + expectedTotalFlow); for (int i = 0; i < numArcs; ++i) { Console.WriteLine("Arc " + i + " (" + maxFlow.Tail(i) + " -> " + maxFlow.Head(i) + "), capacity = " + maxFlow.Capacity(i) + ") computed = " + maxFlow.Flow(i) + ", expected = " + expectedFlows[i]); } } else { Console.WriteLine("Solving the max flow problem failed. Solver status: " + solveStatus); } }
public static void Main() { int[,] graph = { { 0, 5, 4, 0, 0, 0 }, { 0, 0, 3, 5, 3, 0 }, { 0, 0, 0, 8, 2, 0 }, { 0, 0, 0, 0, 6, 4 }, { 0, 0, 0, 0, 0, 5 }, { 0, 0, 0, 0, 0, 0 } }; var m = new MaxFlow(); Console.OutputEncoding = Encoding.UTF8; Console.WriteLine("Максимальний потік " + m.FordFulkerson(graph, 0, 5)); Console.ReadKey(); }
void Calc() { int N = re.i(); N++; long[] A = new long[N]; long count = 0; for (int i = 1; i < N; i++) { A[i] = re.i(); count += Math.Max(A[i], 0); } List <int> f = new List <int>(); List <int> t = new List <int>(); List <long> cost = new List <long>(); for (int i = 0; i < N; i++) { if (A[i] > 0) { f.Add(N); t.Add(i); cost.Add(A[i]); } else { f.Add(i); t.Add(N + 1); cost.Add(-A[i]); } } for (int i = 1; i < N; i++) { for (int j = i * 2; j < N; j += i) { f.Add(j); t.Add(i); cost.Add(1000000000000); } } MaxFlow MF = new MaxFlow(f.ToArray(), t.ToArray(), cost.ToArray(), N + 2, N, N + 1); count -= MF.flow; sb.Append(count + "\n"); }
// このコードはテンプレートとして使えます。 // 0 <= v1 < n1, 0 <= v2 < n2 public static int[][] BipartiteMatching(int n1, int n2, int[][] des) { var sv = n1 + n2; var ev = sv + 1; var mf = new MaxFlow(ev + 1); for (int i = 0; i < n1; ++i) { mf.AddEdge(sv, i, 1); } for (int j = 0; j < n2; ++j) { mf.AddEdge(n1 + j, ev, 1); } foreach (var e in des) { mf.AddEdge(e[0], n1 + e[1], 1); } mf.Dinic(sv, ev); var map = mf.Map; var r = new List <int[]>(); foreach (var se in map[sv]) { if (se.Capacity > 0) { continue; } foreach (var e in map[se.To]) { if (e.Capacity == 0) { r.Add(new[] { se.To, e.To - n1 }); break; } } } return(r.ToArray()); }
private static void SolveMaxFlow() { Console.WriteLine("Max Flow Problem"); int numNodes = 6; int numArcs = 9; int[] tails = {0, 0, 0, 0, 1, 2, 3, 3, 4}; int[] heads = {1, 2, 3, 4, 3, 4, 4, 5, 5}; int[] capacities = {5, 8, 5, 3, 4, 5, 6, 6, 4}; int[] expectedFlows = {4, 4, 2, 0, 4, 4, 0, 6, 4}; int expectedTotalFlow = 10; MaxFlow maxFlow = new MaxFlow(); for (int i = 0; i < numArcs; ++i) { int arc = maxFlow.AddArcWithCapacity(tails[i], heads[i], capacities[i]); if (arc != i) throw new Exception("Internal error"); } int source = 0; int sink = numNodes - 1; Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " + numArcs + " arcs, source=" + source + ", sink=" + sink); int solveStatus = maxFlow.Solve(source, sink); if (solveStatus == MaxFlow.OPTIMAL) { long totalFlow = maxFlow.OptimalFlow(); Console.WriteLine("total computed flow " + totalFlow + ", expected = " + expectedTotalFlow); for (int i = 0; i < numArcs; ++i) { Console.WriteLine("Arc " + i + " (" + maxFlow.Head(i) + " -> " + maxFlow.Tail(i) + "), capacity = " + maxFlow.Capacity(i) + ") computed = " + maxFlow.Flow(i) + ", expected = " + expectedFlows[i]); } } else { Console.WriteLine("Solving the max flow problem failed. Solver status: " + solveStatus); } }
public void Solve() { int N = NextInt(); var s = 0; var t = 2 * N + 1; var mf = new MaxFlow(t + 1); var A = new List <ti2>(); var B = new List <ti2>(); N.REP(i => { A.Add(NextInt(), NextInt()); mf.Add(s, i + 1, 1); }); N.REP(i => { B.Add(NextInt(), NextInt()); mf.Add(i + N + 1, t, 1); }); for (int i = 0; i < N; i++) { var ax = A[i].Item1; var ay = A[i].Item2; for (int j = 0; j < N; j++) { var bx = B[j].Item1; var by = B[j].Item2; if (ax < bx && ay < by) { mf.Add(i + 1, j + N + 1, 1); } } } mf.Run(s, t).WL(); return; }
public static int Solve(HashSet <string>[] sent) { int N = sent.Length; Dictionary <string, int> words = new Dictionary <string, int>(); int[][] ws = new int[N][]; for (int i = 0; i < N; i++) { ws[i] = new int[sent[i].Count]; int j = 0; foreach (string w in sent[i]) { if (!words.ContainsKey(w)) { words[w] = words.Count; } ws[i][j++] = words[w]; } } MaxFlow mf = new MaxFlow(N + words.Count * 2); for (int i = 0; i < words.Count; i++) { mf.Add(N + i, N + words.Count + i, 1); } for (int i = 0; i < N; i++) { for (int j = 0; j < ws[i].Length; j++) { mf.Add(i, N + ws[i][j], 1); mf.Add(N + words.Count + ws[i][j], i, 1); } } return(mf.NetworkFlow(0, 1)); }
private static void SolveMaxFlow() { Console.WriteLine("Max Flow Problem"); int numNodes = 6; int numArcs = 9; int[] tails = { 0, 0, 0, 0, 1, 2, 3, 3, 4 }; int[] heads = { 1, 2, 3, 4, 3, 4, 4, 5, 5 }; int[] capacities = { 5, 8, 5, 3, 4, 5, 6, 6, 4 }; int[] expectedFlows = { 4, 4, 2, 0, 4, 4, 0, 6, 4 }; int expectedTotalFlow = 10; StarGraph graph = new StarGraph(numNodes, numArcs); MaxFlow maxFlow = new MaxFlow(graph, 0, numNodes - 1); for (int i = 0; i < numArcs; ++i) { int arc = graph.AddArc(tails[i], heads[i]); maxFlow.SetArcCapacity(arc, capacities[i]); } Console.WriteLine("Solving max flow with " + numNodes + " nodes, and " + numArcs + " arcs, source = 0, sink = " + (numNodes - 1)); if (maxFlow.Solve()) { long totalFlow = maxFlow.GetOptimalFlow(); Console.WriteLine("total computed flow " + totalFlow + ", expected = " + expectedTotalFlow); for (int i = 0; i < numArcs; ++i) { Console.WriteLine("Arc " + i + " (" + heads[i] + " -> " + tails[i] + ", capacity = " + capacities[i] + ") computed = " + maxFlow.Flow(i) + ", expected = " + expectedFlows[i]); } } else { Console.WriteLine("No solution found"); } }
public void Solve() { var n = sc.Integer(); var g = sc.Integer(); var E = sc.Integer(); var p = sc.Integer(g); var G = new MaxFlow(n + 1); for (int i = 0; i < E; i++) { var a = sc.Integer(); var b = sc.Integer(); G.AddUndirectedEdge(a, b, 1); } foreach (var q in p) { G.AddDirectedEdge(q, n, 1); } var cost = G.GetMaxFlow(0, n); IO.Printer.Out.WriteLine(cost); }
static object Solve() { var(h, w, n) = Read3(); var ps = Array.ConvertAll(new bool[n], _ => Read4()); var sv = 400; var ev = sv + 1; var mf = new MaxFlow(ev + 1); for (int i = 0; i < h; i++) { mf.AddEdge(sv, i, 1); } for (int i = 0; i < w; i++) { mf.AddEdge(300 + i, ev, 1); } for (int i = 0; i < n; i++) { var(a, b, c, d) = ps[i]; var ri = 100 + i; var ci = 200 + i; mf.AddEdge(ri, ci, 1); for (int j = a - 1; j < c; j++) { mf.AddEdge(j, ri, 1); } for (int j = b - 1; j < d; j++) { mf.AddEdge(ci, 300 + j, 1); } } return(mf.Dinic(sv, ev)); }
private static void Go() { var n = RI(); var m = RI(); var x = new List <Item>(); var p = new List <Item>(); var extraX = new List <Item>(); var extraP = new List <Item>(); for (int i = 0; i < m; i++) { var newItem = new Item(); newItem.Tp = ReadAnyOf(new char[] { 'x', '+', 'o' }); newItem.X = RI() - 1; newItem.Y = RI() - 1; if (newItem.Tp == 'x' || newItem.Tp == 'o') { x.Add(newItem); } if (newItem.Tp == '+' || newItem.Tp == 'o') { p.Add(newItem); } } var xx = Enumerable.Range(0, n).Except(x.Select(xxx => xxx.X)).ToList(); var yy = Enumerable.Range(0, n).Except(x.Select(xxx => xxx.Y)).ToList(); for (int i = 0; i < xx.Count; i++) { extraX.Add(new Item() { X = xx[i], Y = yy[i], Tp = 'x' }); } // 0 - root // 1 - N+N-1 > D1 // N+N - N+N+N+N-1 > D // 4N > exist. var d1 = new bool[n + n - 1]; // x+y var d2 = new bool[n + n - 1]; // x-y+n-1 foreach (var t in p) { d1[t.X + t.Y] = true; d2[t.X - t.Y + n - 1] = true; } var nn = 4 * n + 1; var map = new int[nn, nn]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (!d1[i + j] && !d2[i - j + n - 1]) { var d1Id = i + j; var d2Id = i - j + n - 1; var v1 = 1 + d1Id; var v2 = n + n + d2Id; map[0, v1] = 1; map[v1, v2] = 1; map[v2, nn - 1] = 1; } } } var flow = new MaxFlow(map, nn); var maxFlow = flow.GetMaxFlow(0, nn - 1); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (!d1[i + j] && !d2[i - j + n - 1]) { var d1Id = i + j; var d2Id = i - j + n - 1; var v1 = 1 + d1Id; var v2 = n + n + d2Id; if (map[v1, v2] == 0) { extraP.Add(new Item() { X = i, Y = j, Tp = '+' }); } } } } var q1 = new char[n, n]; foreach (var t in x) { q1[t.X, t.Y] = t.Tp; } foreach (var t in p) { q1[t.X, t.Y] = t.Tp; } var q2 = (char[, ])(q1.Clone()); foreach (var t in extraX) { if (q2[t.X, t.Y] == '+') { t.Tp = 'o'; } q2[t.X, t.Y] = t.Tp; } foreach (var t in extraP) { if (q2[t.X, t.Y] == 'x') { t.Tp = 'o'; } q2[t.X, t.Y] = t.Tp; } var result = new List <Item>(); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (q1[i, j] != q2[i, j]) { result.Add(new Item() { X = i, Y = j, Tp = q2[i, j] }); } } } var sb = new StringBuilder(); var max = x.Count + p.Count + extraX.Count + extraP.Count; sb.Append(max + " " + result.Count); foreach (var t in result) { sb.AppendLine(); sb.Append(t.ToString()); } SetAnswer(sb.ToString()); }
public void Solve() { var n = ri; const int MAX = 10000005; var a = new int[MAX]; var b = new int[MAX]; foreach (var x in sc.Integer(n)) { a[x] = 1; } for (int i = 0; i < MAX - 1; i++) { b[i] = a[i + 1] ^ a[i]; } var xs = Enumerate(2, x => new List <int>()); for (int i = 0; i < MAX; i++) { if (b[i] == 1) { xs[i % 2].Add(i); } } var isprime = MathEx.Sieve(10000005); isprime[2] = false; var m = xs[0].Count + xs[1].Count; Debug.WriteLine(m); Debug.WriteLine(xs[0].AsJoinedString()); Debug.WriteLine(xs[1].AsJoinedString()); var G = new MaxFlow(m + 2); for (int i = 0; i < xs[0].Count; i++) { for (int j = 0; j < xs[1].Count; j++) { if (isprime[Math.Abs(xs[0][i] - xs[1][j])]) { G.AddDirectedEdge(i, xs[0].Count + j, 1); } } } var f = m; var t = m + 1; for (int i = 0; i < xs[0].Count; i++) { G.AddDirectedEdge(f, i, 1); } for (int i = 0; i < xs[1].Count; i++) { G.AddDirectedEdge(xs[0].Count + i, t, 1); } var mf = G.Execute(f, t); var ans = mf; var u = xs[0].Count - mf; var v = xs[1].Count - mf; ans += 2 * (u / 2); ans += 2 * (v / 2); if (u % 2 == 1) { ans += 3; } IO.Printer.Out.WriteLine(ans); }
static void Main() { var(n, m) = Read2(); var s = Array.ConvertAll(new bool[n], _ => Console.ReadLine().ToCharArray()); var sv = n * m; var ev = sv + 1; var mf = new MaxFlow(ev + 1); var vs0 = new List <int>(); var vs1 = new HashSet <int>(); // checker board for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (s[i][j] == '#') { continue; } var v = m * i + j; if ((i + j) % 2 == 0) { mf.AddEdge(sv, v, 1); vs0.Add(v); } else { mf.AddEdge(v, ev, 1); vs1.Add(v); } } } foreach (var v in vs0) { if (vs1.Contains(v - m)) { mf.AddEdge(v, v - m, 1); } if (vs1.Contains(v + m)) { mf.AddEdge(v, v + m, 1); } if (v % m != 0 && vs1.Contains(v - 1)) { mf.AddEdge(v, v - 1, 1); } if (v % m != m - 1 && vs1.Contains(v + 1)) { mf.AddEdge(v, v + 1, 1); } } var M = mf.Dinic(sv, ev); var map = mf.Map; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (s[i][j] == '#') { continue; } var v = m * i + j; if ((i + j) % 2 == 0) { var v2 = map[v].FirstOrDefault(e => e.Capacity == 0 && e.To != sv)?.To; if (v2 == null) { continue; } var(i2, j2) = ((int)v2 / m, (int)v2 % m); if (i == i2) { s[i][Math.Min(j, j2)] = '>'; s[i][Math.Max(j, j2)] = '<'; } else { s[Math.Min(i, i2)][j] = 'v'; s[Math.Max(i, i2)][j] = '^'; } } } } Console.WriteLine(M); foreach (var r in s) { Console.WriteLine(new string(r)); } }
public static string Solve() { // Read input string[] ps = Console.ReadLine().Split(); int N = int.Parse(ps[0]); int R = int.Parse(ps[1]); int O = int.Parse(ps[2]); int Y = int.Parse(ps[3]); int G = int.Parse(ps[4]); int B = int.Parse(ps[5]); int V = int.Parse(ps[6]); // Static stuff int[] counts = new int[6]; string chars = "RYBGVO"; counts[0] = R; counts[1] = Y; counts[2] = B; counts[3] = G; counts[4] = V; counts[5] = O; bool[,] conflicts = new bool[7, 7]; for (int i = 0; i < 6; i++) { conflicts[i, i] = true; } for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i != j) { conflicts[i, 3 + j] = conflicts[3 + j, i] = true; } } } // Do a matching to find a neighbour for everyone MaxFlow mf = new MaxFlow(N * 2); int idx = 0; int[] col = new int[N]; for (int i = 0; i < 6; i++) { for (int j = 0; j < counts[i]; j++) { col[idx++] = i; } } for (int i = 0; i < N; i++) { mf.Add(mf.Source, i, 1); mf.Add(N + i, mf.Sink, 1); for (int j = 0; j < N; j++) { if (!conflicts[col[i], col[j]]) { mf.Add(i, N + j, 1); } } } if (mf.NetworkFlow() != N) { return(null); } int[] next = new int[N]; for (int i = 0; i < N; i++) { while (mf.flow[i, N + next[i]] == 0) { next[i]++; } } // Construct cycles bool[] done = new bool[N]; List <List <int> > cycles = new List <List <int> >(); for (int i = 0; i < N; i++) { if (done[i]) { continue; } List <int> cycle = new List <int>(); cycle.Add(i); int cur = next[i]; while (cur != i) { done[cur] = true; cycle.Add(cur); cur = next[cur]; } cycles.Add(cycle); } while (cycles.Count > 1) { // merge two cycles bool found = false; int mergeC = -1; int mergeI = -1; int mergeK = -1; for (int i = 0; !found && i < cycles[0].Count; i++) { for (int j = 1; !found && j < cycles.Count; j++) { for (int k = 0; !found && k < cycles[j].Count; k++) { if (col[cycles[0][i]] == col[cycles[j][k]]) { found = true; mergeC = j; mergeI = i; mergeK = k; } } } } if (!found) { return(null); } List <int> comb = new List <int>(); comb.AddRange(cycles[0].GetRange(0, mergeI)); comb.AddRange(cycles[mergeC].GetRange(mergeK, cycles[mergeC].Count - mergeK)); comb.AddRange(cycles[mergeC].GetRange(0, mergeK)); comb.AddRange(cycles[0].GetRange(mergeI, cycles[0].Count - mergeI)); cycles.RemoveAt(0); cycles.RemoveAt(0); cycles.Add(comb); } // Construct the anwer char[] res = new char[N]; for (int i = 0; i < N; i++) { res[i] = chars[col[cycles[0][i]]]; } return(new string(res)); }
public static void Main(string[] args) { int cases = int.Parse(Console.ReadLine()); while (cases-- > 0) { int N = int.Parse(Console.ReadLine()); string[] grid = new string[N]; for (int i = 0; i < N; i++) { grid[i] = Console.ReadLine(); } int notPlayed = 0; int[,] ind = new int[N, N]; for (int i = 0; i < N; i++) { for (int j = i + 1; j < N; j++) { if (grid[i][j] == '.') { ind[i, j] = N + notPlayed++; } } } MaxFlow mf = new MaxFlow(notPlayed + N); int[] pts = new int[N]; int[] optpts = new int[N]; int totalP = 0; for (int i = 0; i < N; i++) { mf.Add(i, mf.Sink, 2 * N); for (int j = 0; j < N; j++) { if (grid[i][j] == '.') { optpts[i] += 2; if (i < j) { totalP += 2; mf.Add(mf.Source, ind[i, j], 2); mf.Add(ind[i, j], i, 2); mf.Add(ind[i, j], j, 2); } } else if (grid[i][j] == '1') { pts[i] += 2; } else if (grid[i][j] == 'd') { pts[i] += 1; } } } List <int> canWin = new List <int>(); for (int i = 0; i < N; i++) { bool ok = true; for (int j = 0; j < N; j++) { if (j == i) { mf.Capacity[j, mf.Sink] = optpts[i]; } else { mf.Capacity[j, mf.Sink] = pts[i] + optpts[i] - pts[j]; ok &= mf.Capacity[j, mf.Sink] >= 0; } } if (ok && mf.NetworkFlow() == totalP) { canWin.Add(i + 1); } } Console.WriteLine(string.Join(" ", canWin.Select(i => i.ToString()).ToArray())); } }
void Calc() { int N = int.Parse(Console.ReadLine()); string[] str = Console.ReadLine().Split(' '); int[] X = new int[N]; for (int i = 0; i < N; i++) { X[i] = int.Parse(str[i]); } List <int> Diff = new List <int>(); Diff.Add(X[0]); Diff.Add(X[N - 1] + 1); for (int i = 1; i < N; i++) { if (X[i] != X[i - 1] + 1) { Diff.Add(X[i]); } } for (int i = 0; i < N - 1; i++) { if (X[i] + 1 != X[i + 1]) { Diff.Add(X[i] + 1); } } int[] diff = Diff.ToArray(); int o = 0; int e = 0; for (int i = 0; i < diff.Length; i++) { if (diff[i] % 2 == 0) { e++; } else { o++; } } int[] Odd = new int[o]; int[] Even = new int[e]; o = 0; e = 0; for (int i = 0; i < diff.Length; i++) { if (diff[i] % 2 == 0) { Even[e] = diff[i]; e++; } else { Odd[o] = diff[i]; o++; } } List <int> f = new List <int>(); List <int> t = new List <int>(); List <long> capa = new List <long>(); int S = 0; int Ef = 1; int Of = e + 1; int T = o + e + 1; for (int i = 0; i < e; i++) { f.Add(S); t.Add(Ef + i); capa.Add(1); } for (int i = 0; i < o; i++) { f.Add(Of + i); t.Add(T); capa.Add(1); } Generateprimenumber G = new Generateprimenumber(10000); for (int i = 0; i < e; i++) { for (int j = 0; j < o; j++) { if (G.Prime(Math.Max(Even[i] - Odd[j], Odd[j] - Even[i]))) { f.Add(Ef + i); t.Add(Of + j); capa.Add(1); } } } MaxFlow Flow = new MaxFlow(f.ToArray(), t.ToArray(), capa.ToArray(), o + e + 2, 0, o + e + 1); int flow = (int)Flow.flow; int count = diff.Length - flow; if (e % 2 != flow % 2) { count++; } sb.Append(count + "\n"); }
/// <summary> /// Wyznacza maksymalny przepływ o minimalnym koszcie /// </summary> /// <param name="g">Graf przepustowości</param> /// <param name="c">Graf kosztów</param> /// <param name="source">Wierzchołek źródłowy</param> /// <param name="target">Wierzchołek docelowy</param> /// <param name="parallel">Informacja czy algorytm ma korzystać z równoległej wersji algorytmu Forda-Bellmana</param> /// <param name="mf">Metoda wyznaczania wstępnego maksymalnego przepływu (bez uwzględniania kosztów)</param> /// <param name="af">Metoda powiększania przepływu</param> /// <param name="matrixToAVL">Czy optymalizować sposób reprezentacji grafu rezydualnego</param> /// <returns> /// Krotka (value, cost, flow) składająca się z /// wartości maksymalnego przepływu, jego kosztu i grafu opisującego ten przepływ /// </returns> /// <exception cref="ArgumentException"></exception> /// <remarks> /// Można wybrać metodę wyznaczania wstępnego maksymalnego przepływu (parametr mf).<para/> /// Domyślna wartość mf (null) oznacza konstrukcję wstępnego przepływu z wykorzystaniem sztucznej krawędzi.<para/> /// Można wybrać metodę powiększania przepływu (parametr pf).<para/> /// Znaczenie tego parametru zależy od wybranej metody wyznaczania wstępnego maksymalnego przepływu /// (parametr mf), dla niektórych wartości parametru mf /// (np. <see cref="MaxFlowGraphExtender.FordFulkersonDinicMaxFlow"/>) /// jawne wskazanie metody powiększania przepływu jest konieczne /// (pozostawienie domyślnej wartości parametru pf (null) /// spowoduje zgłoszenie wyjątku <see cref="ArgumentException"/>).<para/> /// Metoda uruchomiona dla grafu nieskierowanego lub grafu /// z ujemnymi przepustowościami krawędzi zgłasza wyjątek <see cref="ArgumentException"/>.<para/> /// Gdy grafy przepustowości i kosztów mają różną strukturę lub parametry /// source i target są równe metoda również zgłasza wyjątek <see cref="ArgumentException"/>.<para/> /// Gdy w grafie przepustowości istnieją krawędzie w obu kierunkach /// pomiędzy parą wierzchołków metoda również zgłasza wyjątek <see cref="ArgumentException"/>. /// </remarks> /// <seealso cref="MinCostFlowGraphExtender"/> /// <seealso cref="ASD.Graphs"/> public static (double value, double cost, Graph flow) MinCostFlow(this Graph g, Graph c, int source, int target, bool parallel = false, MaxFlow mf = null, AugmentFlow af = null, bool matrixToAVL = true) { if (!g.Directed) { throw new ArgumentException("Undirected graphs are not allowed"); } if (source == target) { throw new ArgumentException("Source and target must be different"); } if (g.VerticesCount != c.VerticesCount) { throw new ArgumentException("Inconsistent capacity and cost graphs"); } var fordBellmanShortestPaths = parallel ? ShortestPathsGraphExtender.FordBellmanShortestPathsParallel : new FordBellmanShortestPaths(ShortestPathsGraphExtender.FordBellmanShortestPaths); var gOut = new HashSet <int>(); var cOut = new HashSet <int>(); for (var i = 0; i < g.VerticesCount; i++) { gOut.Clear(); cOut.Clear(); foreach (var edge in g.OutEdges(i)) { if (edge.Weight < 0.0) { throw new ArgumentException("Negative capacity edges are not allowed"); } if (!g.GetEdgeWeight(edge.To, edge.From).IsNaN()) { throw new ArgumentException( "Edges in both directions between pair of vertices are not allowed"); } gOut.Add(edge.To); } foreach (var edge in c.OutEdges(i)) { cOut.Add(edge.To); } if (!gOut.SetEquals(cOut)) { throw new ArgumentException("Inconsistent capacity and cost graphs"); } } var tempCost = double.NaN; var tempFlow = double.NaN; var maxFlow = double.NaN; Graph flow; if (mf != null) { (maxFlow, flow) = mf(g, source, target, af, matrixToAVL); } else { if (!(tempFlow = g.GetEdgeWeight(source, target)).IsNaN()) { g.DelEdge(source, target); } if (!(tempCost = c.GetEdgeWeight(source, target)).IsNaN()) { c.DelEdge(source, target); } flow = g.IsolatedVerticesGraph(); var maxPossibleFlow = g.OutEdges(source).Sum(e => e.Weight); g.AddEdge(source, target, maxPossibleFlow + 1.0); flow.AddEdge(source, target, maxPossibleFlow + 1.0); var maxPossibleCost = 0.0; for (var i = 0; i < c.VerticesCount; i++) { foreach (var edge4 in c.OutEdges(i)) { maxPossibleCost += Math.Abs(edge4.Weight); flow.AddEdge(edge4.From, edge4.To, 0.0); } } c.AddEdge(source, target, maxPossibleCost + 1.0); } var residualFlow = flow.IsolatedVerticesGraph(); var residualCost = flow.IsolatedVerticesGraph(); for (var i = 0; i < flow.VerticesCount; i++) { foreach (var edge in flow.OutEdges(i)) { var something = Math.Min(g.GetEdgeWeight(edge.From, edge.To), double.MaxValue) - edge.Weight; if (something > 0.0) { residualFlow.AddEdge(edge.From, edge.To, something); residualCost.AddEdge(edge.From, edge.To, c.GetEdgeWeight(edge.From, edge.To)); } if (edge.Weight > 0.0) { residualFlow.AddEdge(edge.To, edge.From, edge.Weight); residualCost.AddEdge(edge.To, edge.From, -c.GetEdgeWeight(edge.From, edge.To)); } } } var foundFlow = 0.0; while (!fordBellmanShortestPaths(residualCost, target, out var pi)) { var cycle = residualCost.FindNegativeCostCycle(pi).cycle; var cycleMaxFlow = double.PositiveInfinity; var flag = false; foreach (var edge in cycle) { if (edge.From == target && edge.To == source) { flag = true; } var weight = residualFlow.GetEdgeWeight(edge.From, edge.To); if (cycleMaxFlow > weight) { cycleMaxFlow = weight; } } if (flag) { foundFlow += cycleMaxFlow; } foreach (var edge in cycle) { if (flag = (flow.GetEdgeWeight(edge.To, edge.From) > 0.0)) { var weight = flow.ModifyEdgeWeight(edge.To, edge.From, -cycleMaxFlow); if (weight < 0.0) { flow.ModifyEdgeWeight(edge.To, edge.From, -weight); flow.ModifyEdgeWeight(edge.From, edge.To, -weight); } } else { flow.ModifyEdgeWeight(edge.From, edge.To, cycleMaxFlow); } if (residualFlow.ModifyEdgeWeight(edge.From, edge.To, -cycleMaxFlow) == 0.0) { residualFlow.DelEdge(edge); residualCost.DelEdge(edge); } if (residualFlow.ModifyEdgeWeight(edge.To, edge.From, cycleMaxFlow).IsNaN()) { residualFlow.AddEdge(edge.To, edge.From, cycleMaxFlow); var weight = (flag ? c.GetEdgeWeight(edge.To, edge.From) : c.GetEdgeWeight(edge.From, edge.To)); residualCost.AddEdge(edge.To, edge.From, flag ? weight : (-weight)); } } } if (mf == null) { g.DelEdge(source, target); c.DelEdge(source, target); flow.DelEdge(source, target); if (!tempFlow.IsNaN()) { foundFlow += tempFlow; g.AddEdge(source, target, tempFlow); c.AddEdge(source, target, tempCost); flow.AddEdge(source, target, tempFlow); } maxFlow = foundFlow; } var cost = 0.0; for (var k = 0; k < flow.VerticesCount; k++) { cost += flow.OutEdges(k).Sum(e => e.Weight * c.GetEdgeWeight(e.From, e.To)); } return(maxFlow, cost, flow); }
void Calc() { string[] str = Console.ReadLine().Split(' '); int H = int.Parse(str[0]); int W = int.Parse(str[1]); int S = -1; int G = -1; int si = -1; int sj = -1; int gi = -1; int gj = -1; List <int> f = new List <int>(); List <int> t = new List <int>(); List <long> c = new List <long>(); int count = H + W; for (int i = 0; i < H; i++) { string s = Console.ReadLine(); for (int j = 0; j < W; j++) { if (s[j] != '.') { f.Add(count); t.Add(i); f.Add(count); t.Add(H + j); if (s[j] == 'S') { S = count; c.Add(1000000000); c.Add(1000000000); si = i; sj = j; } else if (s[j] == 'T') { G = count; c.Add(1000000000); c.Add(1000000000); gi = i; gj = j; } else { c.Add(1); c.Add(1); } count++; } } } if (si == gi || sj == gj) { sb.Append("-1\n"); return; } MaxFlow F = new MaxFlow(f.ToArray(), t.ToArray(), c.ToArray(), count, S, G); sb.Append(F.flow + "\n"); }