Edmonds Karp's algorythm

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <set>
#include <queue>
#include <map>

using namespace std;

struct edge
{
    long long cap, f;
    long long from, to;
};

const long long inf = 2000000007;

vector<edge> E;
vector<vector<long long> > g;
long long used[200];

void add_edge(long long from, long long to, long long cap)
{
    edge e;
    e.cap = cap;
    e.from = from;
    e.to = to;
    e.f = 0;
    g[from].push_back(E.size());
    E.push_back(e);
    //return;
}

long long bfs(long long S, long long T, long long n)
{
    vector<long long> flow(n, inf);
    queue<long long>q;
    vector<long long> p(n, -1);
    q.push(S);
    used[S] = 1;
    flow[S] = inf;
    while (!q.empty())
    {
        long long v = q.front();
        q.pop();
        for (long long i = 0; i < g[v].size(); i++)
        {
            long long r = g[v][i];
            long long to = E[r].to;
            if (/*!used[to]*/ p[to] == -1 && E[r].cap > E[r].f)
            {
                //used[v] = 1;
                p[to] = r;
                flow[to] = min(E[r].cap - E[r].f, flow[v]);
                q.push(to);
            }
        }
    }

    //if (!used[T])
    if (p[T] == -1)
        return 0;

    long long f = flow[T];
    for (long long v = T; v != S; v = E[p[v]].from)
    {
        long long r = p[v];
        E[r].f += f;
        E[r ^ 1].f -= f;
    }
    return f;
}

int main()
{

    long long n, k;
    cin >> n >> k;
    long long x, y, c;
    g.resize(n);
    for (long long i = 0; i < k; i++)
    {
        cin >> x >> y >> c;
        x--;
        y--;
        add_edge(x, y, c);
        add_edge(y, x, 0);
        add_edge(y, x, c);
        add_edge(x, y, 0);
    }


    long long ans = 0;

    while (1)
    {
        fill(used, used + n, 0);
        long long f = bfs(0, n - 1, n);
        if (f <= 0)
            break;
        ans += f;
    }

    cout << ans << endl;

    return 0;
}