820 - Internet Bandwidth

#include<bits/stdc++.h>
#define INF 100000
#define UNINITIALIZED -1
#define sz 102
using namespace std;

vector<int>graph[sz];
int currentPathCapacity[sz];
int par[sz];
int capacities[sz][sz];
int flowPassed[sz][sz];

void reset(int nodes)
{
    for(int i=0; i<=nodes; i++)
    {
        graph[i].clear();
    }

    memset(flowPassed,0,sizeof(flowPassed));
    memset(capacities,0,sizeof(capacities));
}

int bfs(int startnode,int endnode)
{
    memset(par,UNINITIALIZED,sizeof(par));
    memset(currentPathCapacity,0,sizeof(currentPathCapacity));

    queue<int>q;

    q.push(startnode);
    par[startnode] = -2;
    currentPathCapacity[startnode] = INF;

    while(!q.empty())
    {
        int currentnode = q.front();
        q.pop();
        for(int i=0; i<graph[currentnode].size(); i++)
        {
            int to = graph[currentnode][i];

            if(par[to] == UNINITIALIZED)
            {
                int a = capacities[currentnode][to]-flowPassed[currentnode][to];
                if(a>0)
                {
                    par[to] = currentnode;

                    currentPathCapacity[to] = min(currentPathCapacity[currentnode],a);

                    if(to==endnode)
                    {
                        return currentPathCapacity[endnode];
                    }

                    q.push(to);
                }
            }
        }
    }

    return 0;
}

int edmondsKarp(int startnode,int endnode)
{
    int maxFlow=0;
    while(true)
    {
        int flow = bfs(startnode,endnode);

        if(flow==0)
        {
            break;
        }

        maxFlow+=flow;

        int currentnode = endnode;

        while(currentnode!=startnode)
        {
            int previousnode = par[currentnode];
            flowPassed[previousnode][currentnode]+=flow;
            flowPassed[currentnode][previousnode]-=flow;

            currentnode=previousnode;
        }
    }

    return maxFlow;

}

int main()
{
    int nodes,edges,i,a,b,bandwidth,s,d,maxFlow,test=0;
    while(scanf("%d",&nodes)&&nodes)
    {
        scanf("%d%d%d",&s,&d,&edges);
        for(i=0; i<edges; i++)
        {
            scanf("%d%d%d",&a,&b,&bandwidth);
            graph[a].push_back(b);
            graph[b].push_back(a);

            capacities[a][b]+=bandwidth;
            capacities[b][a]+=bandwidth;
        }

        maxFlow = edmondsKarp(s,d);

        printf("Network %d\n",++test);

        printf("The bandwidth is %d.\n\n",maxFlow);

        reset(nodes);
    }
    return 0;
}