Internet connection

input/code.cpp: In function 'int main(int, const char**)':
input/code.cpp:96:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for(int i = 0; i <= n; i++){
                    ~~^~~~
input/code.cpp:97:26: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
         for(int j = 0; j <= n; j++){
                        ~~^~~~
input/code.cpp:102:22: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for(int i = 0; i < m; i++){
                    ~~^~~
input/code.cpp: In instantiation of 'std::__cxx11::list<T_NODE> bfs(const T_VALUE*, T_NODE, T_NODE, T_NODE) [with T_NODE = unsigned int; T_VALUE = long unsigned int]':
input/code.cpp:80:27:   required from 'T_VALUE max_flow(T_VALUE*, T_NODE, T_NODE, T_NODE) [with T_NODE = unsigned int; T_VALUE = long unsigned int]'
input/code.cpp:107:69:   required from here
input/code.cpp:9:22: warning: comparison between signed and unsigned...

#include <iostream>
#include <list>
#include <queue>

template<typename T_NODE, typename T_VALUE>
std::list<T_NODE> bfs(const T_VALUE *data, const T_NODE n, const T_NODE v1, const T_NODE v2){
    
    T_NODE visited[n + 1];
    for(int i = 1; i <= n; i++)
        visited[i] = 0;
    visited[v1] = v1;
    
    std::queue<T_NODE> queue = {};
    queue.push(v1);
    
    while(!queue.empty()){
        T_NODE v = queue.front();
        queue.pop();
        if(data[v * (n + 1) + v2] > 0){
            visited[v2] = v;
            break;
        }
        for(int i = 1; i <= n; i++){
            if(visited[i] == 0 && data[v * (n + 1) + i] > 0){
                visited[i] = v;
                queue.push(i);
            }
        }
    }
    
    std::list<T_NODE> result = {};
    
    if(visited[v2] != 0){
        result.push_front(v2);
        T_NODE v = v2;
        while(v != v1){
            v = visited[v];
            result.push_front(v);
        }
    }
    return result;
}

template<typename T_NODE, typename T_VALUE>
T_VALUE path_max_throughput(const T_VALUE *data, const T_NODE n, std::list<T_NODE> path){
    typename std::list<T_NODE>::iterator it = path.begin();
    T_NODE v1 = *(it++);
    T_VALUE result = data[v1 * (n + 1) + *it];
    
    if(it != path.end()){
        v1 = *(it++);
        while(it != path.end()){
            T_VALUE value = data[v1 * (n + 1) + *it];
            if(value < result){
                result = value;
            }
            v1 = *(it++);
        }
    }
    return result;
}

template<typename T_NODE, typename T_VALUE>
void path_add_flow(T_VALUE *data, const T_NODE n, std::list<T_NODE> path, const T_VALUE flow){
    typename std::list<T_NODE>::iterator it = path.begin();
    T_NODE v1 = *(it++);
    while(it != path.end()){
        data[v1 * (n + 1) + *it] -= flow;
        data[*it * (n + 1) + v1] += flow;
        v1 = *(it++);
    }
}

template<typename T_NODE, typename T_VALUE>
T_VALUE max_flow(T_VALUE *data, const T_NODE n, const T_NODE source, const T_NODE target){
    typename std::list<T_NODE> path;
    T_VALUE flow = 0;
    
    do{
        path = bfs<T_NODE>(data, n, source, target);
        if(!path.empty()){
            T_VALUE throughput = path_max_throughput<T_NODE, T_VALUE>(data, n, path);
            path_add_flow<T_NODE, T_VALUE>(data, n, path, throughput);
            flow += throughput;
        }
    } while (!path.empty());
    
    return flow;
}

int main(int argc, const char * argv[]) {
    unsigned int n, m;
    std::cin >> n >> m;
    
    unsigned long *data = (unsigned long *)malloc((n + 1) * (n + 1) * sizeof(unsigned long));
    for(int i = 0; i <= n; i++){
        for(int j = 0; j <= n; j++){
            data[i * (n + 1) + j] = 0;
        }
    }

    for(int i = 0; i < m; i++){
        unsigned int a, b;
        std::cin >> a >> b >> data[a * (n + 1) + b];
    }
    
    std::cout << max_flow<unsigned int, unsigned long>(data, n, 1, n) << "\n";
    
    return 0;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED