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);
        }
Esempio n. 2
0
    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]
    }
Esempio n. 3
0
    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);
        }
    }
Esempio n. 4
0
 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);
   }
 }