#include <fstream>
#include <queue>

using namespace std;

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

const int NMAX = 1e3 + 1;

int N, M;

vector < int > G[NMAX];

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

bool Sel[NMAX];
int T[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)
        Sel[i] = 0, T[i] = -1;

    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 MaxFlow (int S, int D)
{
    int flow = 0;

    while(BFS(S, D))
    {
        for(auto it : G[D])
            if(T[it] != -1)
            {
                int Node = it;
                int Min = C[Node][D] - F[Node][D];

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

                ///
                flow += Min;
                ///

                Node = it;
                F[Node][D] += Min;
                /// F[D][Node] -= Min;

                while(Node != S)
                {
                    int Dad = T[Node];
                    F[Dad][Node] += Min;
                    /// F[Node][Dad] -= Min;
                    Node = Dad;
                }
            }
    }

    return flow;
}

int main()
{
    Read();

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

    return 0;
}