Cod sursa(job #2776123)

Utilizator Dragono63Stanciu Rares Stefan Dragono63 Data 18 septembrie 2021 17:54:39
Problema Flux maxim Scor 70
Compilator cpp-64 Status done
Runda Arhiva educationala Marime 2.09 kb
#include <fstream>
#include <string.h>
#include <queue>
#include <vector>
#define NMAX 1005
 
using namespace std;
 
/************************************/
/// INPUT / OUTPUT
 
ifstream f("maxflow.in");
ofstream g("maxflow.out");
/************************************/
/// GLOBAL DECLARATIONS
 
int N, M, S, D;
int maxFlow;
int flow[NMAX][NMAX], parent[NMAX], cap[NMAX][NMAX], currFlow[NMAX];
vector < int > adj[NMAX];
/************************************/
/// FUNCTIONS
 
void ReadInput();
void Solution();
void Output();
/************************************/
///-------------------------------------------------
inline void ReadInput()
{
    f >> N >> M;
    S = 1;
    D = N;
 
    for (int i = 1 ; i <= M ; ++ i)
    {
        int a, b, flux;
        f >> a >> b >> flux;
 
        cap[a][b] = flux;
        adj[a].push_back(b);
        adj[b].push_back(a); 
    }
}
///-------------------------------------------------
int BFS()
{
    memset(parent, -1, sizeof(parent));
    currFlow[S] = 10000000;
    queue < int > q;
    q.push(S);
 
    while (!q.empty())
    {
        int node = q.front();
        q.pop();
 
        for (auto u: adj[node])
        {
            if (parent[u] == -1 && flow[node][u] < cap[node][u])
            {
                parent[u] = node;
                currFlow[u] = min(currFlow[node], cap[node][u] - flow[node][u]);
 
                if (u == D)
                    return currFlow[D];
                q.push(u);
            }
        }
    }
 
    return 0;
}
///-------------------------------------------------
inline void Solution()
{
    while (true)
    {
        int flux = BFS();
 
        if (flux == 0)
            return;
 
        maxFlow += flux;    
        int node = D;
 
        while (node != S)
        {
            int par = parent[node];
            flow[par][node] += flux;
            flow[node][par] -= flux;
            node = par;
        }
    }
}
///-------------------------------------------------
inline void Output()
{
    g << maxFlow;
}
///-------------------------------------------------
int main()
{
    ReadInput();
    Solution();
    Output();
    return 0;
}