this c$++$ program is about Ford$-$Fulkerson Algorithm for Maximum Flow Problem

can someone help me to make this in python?

Make sure the output and input are the same as examples!

code:

#include

#include

#include

#include

#include

#include

#include

using namespace std;

#define V $15$

bool bfs$($int rGraph$[$V$][$V$],$ int s$,$ int t$,$ int parent$[])\{$

bool visited$[$V$]$;

memset$($visited$,0,$ sizeof$($visited$))$;

queue q;

q$.$push$($s$)$;

visited$[$s$]=$ true;

parent$[$s$]=-1$;

while $(!$q$.$empty$())\{$

int u $=$ q$.$front$()$;

q$.$pop$()$;

for $($int v $=0$; v $<$ V; v$++)\{$

if $($visited$[$v$]==$ false && rGraph$[$u$][$v$]>0)\{$

q$.$push$($v$)$;

parent$[$v$]=$ u;

visited$[$v$]=$ true;

$\}$

$\}$

$\}$

return $($visited$[$t$]==$ true$)$;

$\}$

int findDisjointPaths$($int graph$[$V$][$V$],$ int s$,$ int t$)\{$

int u$,$ v;

int rGraph$[$V$][$V$]$;

for $($u $=0$; u $<$ V; u$++)\{$

for $($v $=0$; v $<$ V; v$++)\{$

rGraph$[$u$][$v$]=$ graph$[$u$][$v$]$;

$\}$

$\}$

int parent$[$V$]$;

int max$\_$flow $=0$;

vector$>$ all$\_$path;

while $($bfs$($rGraph$,$ s$,$ t$,$ parent$))\{$

vector current$\_$path;

int path$\_$flow $=$ INT$\_$MAX;

for $($v $=$ t; v $!=$ s; v $=$ parent$[$v$])\{$

u $=$ parent$[$v$]$;

path$\_$flow $=$ min$($path$\_$flow, rGraph$[$u$][$v$])$;

$\}$

for $($v $=$ t; v $!=$ s; v $=$ parent$[$v$])\{$

u $=$ parent$[$v$]$;

current$\_$path.insert$($current$\_$path.begin$(),$ v$)$;

rGraph$[$u$][$v$]-=$ path$\_$flow;

rGraph$[$v$][$u$]+=$ path$\_$flow;

if $($v $!=$ t && v $!=$ s$)\{$

for $($int temp $=0$; temp $<$ V; temp$++)\{$

rGraph$[$temp$][$v$]=0$;

rGraph$[$v$][$temp$]=0$;

$\}$

$\}$

$\}$

max$\_$flow $+=$ path$\_$flow;

all$\_$path.push$\_$back$($current$\_$path$)$;

$\}$

cout $<<$ endl $<<$ max$\_$flow;

for $($int temp $=0$; temp $<$ all$\_$path.size$()$; temp$++)\{$

cout $<<$ endl $<<$ s $<<""$;

for $($int ttemp $=0$; ttemp $<$ all$\_$path$[$temp$].$size$()$; ttemp$++)\{$

cout $<<$ all$\_$path$[$temp$][$ttemp$]<<""$;

$\}$

$\}$

return max$\_$flow;

$\}$

int main$()\{$

$//$V E

int vertex, edge;

cin $>>$ vertex $>>$ edge;

int s$,$ t;

cin $>>$ s $>>$ t;

int graph$[$V$][$V$]=\{0\}$;

for $($int temp $=0$; temp $<$ edge; temp$++)\{$

int a$,$ b;

cin $>>$ a $>>$ b;

graph$[$a$][$b$]=1$;

$\}$

findDisjointPaths$($graph$,$ s$,$ t$)$;

return $0$;

$\}$

Input Format:

The first line of input consists of two positive integers separated by a space, representing the number of vertices and edges in G respectively.

The second line of input consists of two positive integers separated by a space, representing the starting point and endpoint of the path.

Following that, each line contains two integers $($a$,$ b$)$ representing an edge from node a to node b$.$

example: