#include <fstream>
#include <vector>
#include <queue>

using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

const int NMAX = 1e3 + 5;

int N, M;

int C[NMAX][NMAX], F[NMAX][NMAX];

vector < int > G[NMAX];

int T[NMAX];
bool Sel[NMAX];

static inline void Add_Edge (int x, int y, int z)
{
    G[x].push_back(y), G[y].push_back(x);

    C[x][y] = z;

    return;
}

static inline void Read ()
{
    f.tie(nullptr);

    f >> N >> M;

    for(int i = 1; i <= M; ++i)
    {
        int X = 0, Y = 0, Z = 0;
        f >> X >> Y >> Z;

        Add_Edge(X, Y, Z);
    }

    return;
}

static inline void Reset ()
{
    for(int i = 1; i <= N; ++i)
        T[i] = -1, Sel[i] = 0;

    return;
}

static inline bool BFS (int S, int D)
{
    Reset();

    queue < int > Q;
    Q.push(S);

    Sel[S] = 1, T[S] = 0;

    while(!Q.empty())
    {
        int Node = Q.front();
        Q.pop();

        for(auto it : G[Node])
            if(!Sel[it] && F[Node][it] < C[Node][it])
            {
                Sel[it] = 1, T[it] = Node;

                if(it == D)
                    return 1;

                Q.push(it);
            }
    }

    return 0;
}

static inline int my_min (int a, int b)
{
    return ((a < b) ? a : b);
}

static inline int Max_Flow (int S, int D)
{
    int ans = 0;

    while(BFS(S, D))
    {
        for(auto leaf : G[D]) /// Frunza curenta (din arborele BF) nu a fost atinsa in parcurgere;/// Iteram prin lista de vecini a noduluoi Destinatie, incercand ca in cadrul unui loop sa "crestem" cat mai multe muchii nesaturate;
        {
            if(T[leaf] == -1)
                continue;

            int it = leaf;

            int Node = it;
            int Max = C[it][D] - F[it][D];

            while(Node != S)
            {
                int Dad = T[Node];
                Max = my_min(Max, C[Dad][Node] - F[Dad][Node]);

                Node = Dad;
            }

            ans += Max;

            F[it][D] += Max;
            F[D][it] -= Max;

            Node = it;

            while(Node != S)
            {
                int Dad = T[Node];

                F[Dad][Node] += Max;
                F[Node][Dad] -= Max;

                Node = Dad;
            }
        }
    }

    return ans;
}

int main()
{
    Read();

    g << Max_Flow(1, N) << '\n';

    return 0;
}