adj = None
nodes = 0
edges = 0
source = 0
sink = 0

def create_matrix(nodes):
    global sink
    adj = [[0 for _ in range(nodes)] for _ in range(nodes)]
    sink = nodes - 1
    return adj

def bfs():
    visited = [False] * nodes
    parents = [-1] * nodes
    visited[source] = True
    parents[source] = -2
    Q = [source]

    while Q:
        current = Q.pop(0)
        if current == sink:
            return parents
        for i in range(nodes):
            if adj[current][i] > 0 and not visited[i]:
                visited[i] = True
                parents[i] = current
                Q.append(i)
    return None

def find_min(parents):
    current = sink
    minim = 1000000000000
    while current > 0:
        if adj[parents[current]][current] < minim:
            minim = adj[parents[current]][current]
        current = parents[current]
    return minim

def change_capacities(minim, parents):
    current = sink
    while current > 0:
        adj[parents[current]][current] -= minim
        adj[current][parents[current]] += minim
        current = parents[current]

def edmonds_karp():
    parents = bfs()
    max_flow = 0
    while parents:
        mini = find_min(parents)
        max_flow += mini
        change_capacities(mini,parents)
        parents = bfs()
    
    return max_flow

def main():
    global nodes
    global edges
    global adj
    with open("maxflow.in", 'r') as f:
        lines = f.readlines()
        for ind, val in enumerate(lines):
            line = val.split()
            if ind == 0:
                nodes = int(line[0])
                edges = int(line[1])
                adj = create_matrix(nodes)
            else:
                u = int(line[0])-1
                v = int(line[1])-1
                cost = int(line[2])
                adj[u][v] = cost
    
    with open("maxflow.out", "w") as out:
        out.write(str(edmonds_karp()))
        

if __name__ == '__main__':
    main()