maxflow | A library that implements the maxflow-mincut algorithm | Learning library

You only need to change one line, use

G = nx.read_edgelist(filename,nodetype=int,create_using=nx.DiGraph())

instead of

G = nx.read_edgelist("filename",nodetype=int,create_using=nx.DiGraph())

Currently you are using the literal "filename" instead of using the variable filename.

I think your solution can benefit from better graph representation. In particular try to keep a list of neighbours for the BFS. I actually wrote a quite long answer on the graph representation I use for flow algorithms here https://stackoverflow.com/a/23168107/812912

If your solution is still too slow I would recommend switching to Dinic's algorithm it has served me well in many tasks.

Since you are using int n=Integer.parseInt(br.readLine);, Integer.parseInt() always tries to convert your input to the integer one, and assign to integer variable. You don't have to worry about it, as Integer.parseInt() method internally does this.

And as you throw NumberFormatException in method signature, if Integer.parseInt() does not get integer value or something that it can't convert to integer, the NumberFormatException exception will be thrown.

So, if you give number input, n will store the input and you program runs well. If you give input except number (means something that contains character), code will give exception and terminate the execution.

To handle it, you can put your code inside try-catch block to make it properly handle. Like below

You only exported the type constructor, not its data constructor(s). If you want to export the data constructor(s), you can write the can write this between parenthesis in the export:

You have window

Could it be that my implementation of the algorithm is slow or is it normal that max flow algorithm is slower when the number of nodes and edges are large?

I think that the answer is Yes to both:

According to the Wikipedia page on the MaxFlow Problem, the complexity of solutions that are guaranteed to terminate are all O(VE) or worse. The Edmonds-Karp algorithm is O(VE^2).

(V is the number of vertices and E is the number of edges in the graph.)

In short all maxflow algorithms are slow if the number of nodes or edges is large.

However, I think there are also problems in your implementation. For example, the comment on BFS_ method says "find path from nodeU to nodeV if one exists" but what it is doing is to find all paths from nodeU. If you look at it, the nodeV argument isn't used.

And there are lots of micro-optimizations that could be performed. For example:

Just remove all nodes with only one edge (not counting for the two ending nodes).

But this does not account for the nodes "beyond" the ending nodes. If in your original graph we want to calculate the resistance between nodes 5 and 6 then we do not need any other node (nodes 1, 2, 3 and 4 are all irrelevant).

To remove really all nodes that are irrelevant you have to find all different paths between the two ending nodes, and remove all nodes that are not part of any of those paths.

Which lines of the Makefile execute these commands... ?

The short answer is none. The rule...

I've used igraph successfully with some big graphs, though its hard to predict if it will meet your 5 minute mark.

igraph has functions for max_flow (https://igraph.org/r/doc/max_flow.html) and mincut (https://igraph.org/r/doc/min_cut.html).