MaxFlow | high performance Python library for computing the maximum | Learning library

Simple solution if your data is a list with only two elements and last one is empty dict:

Not exactly the best solution but worth giving a try:

First let’s pass everything as a list of flat lists to pd.DataFrame, splitting the keys on / to make them into different columns:

There's many issues. If you use modern C++ and compiler warnings, you can reduce the code and spot the bugs in printing vertex descriptors (printf is just not safe; use the diagnostics!).

Here's my take after review.

Notable changes:

• bundled properties instead of separate interior properties

• this implies passing named arguments (but see https://stackoverflow.com/a/64744086/85371)

• no more global variables, no more loopy initialization if the simple constructor suffices

• no more duplicated code (nothing invites error quite like having capacities1 and capacities2 lying around)

• using clear_vertex instead of just clear_out_edges - this may not make a difference (?) but seems to express intent a bit better

• no more printf (I'll use libfmt, which is also in c++23), so e.g.

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: