Download Speed

input/code.cpp: In function 'int ford_fulkerson(std::vector<std::vector<std::pair<int, int> > >&, int, int, int)':
input/code.cpp:135:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  135 |         for (int i = 1; i < path_reversed.size(); i++)
      |                         ~~^~~~~~~~~~~~~~~~~~~~~~

#include <bits/stdc++.h>
 
#define REP(i, a, b) for (int i = a; i < b; i++)
 
// Type Aliases for 1D and 2D vectors with initialization
#define vll(n, val) vector<long long>(n, val) // 1D vector of long longs with size n, initialized to val
#define ll long long
#define vvi(n, m, val) vector<vector<int>>(n, vector<int>(m, val))              // 2D vector of ints (n x m), initialized to val
#define vvll(n, m, val) vector<vector<long long>>(n, vector<long long>(m, val)) // 2D vector of long longs (n x m), initialized to val
 
using namespace std;
 
void print_vector(vector<int> &x)
{
    for (int v : x)
    {
        cout << v << " ";
    }
    cout << "\n";
}
 
void print_matrix(vector<vector<int>> &matrix)
{
    cout << "\n"
         << "----------------" << "\n";
    for (vector<int> row : matrix)
    {
        print_vector(row);
    }
    cout << "\n"
         << "----------------" << "\n";
}
 
int calc_max_digit(int n)
{
    int max_digit = 0;
    while (n > 0 && max_digit < 9)
    {
        int digit = n % 10;
        if (digit > max_digit)
        {
            max_digit = digit;
        }
        n /= 10;
    }
    return max_digit;
}
 
// edges as edge list for outgoing node as pairs (end, cost)
vector<ll> dijkstras(int start_point, vector<vector<pair<int, int>>> edges)
{
    int n = edges.size();
    vector<bool> processed(n, false);
    vector<ll> distances(n, LLONG_MAX);
    distances[start_point] = 0;
    priority_queue<pair<ll, int>> pq;
    pq.push({0, start_point});
    while (!pq.empty())
    {
        int curr = pq.top().second;
        pq.pop();
        if (processed[curr])
        {
            continue;
        }
        processed[curr] = true;
        ll distance = distances[curr];
 
        for (pair<int, int> edge : edges[curr])
        {
 
            if (distance + edge.second < distances[edge.first])
            {
                distances[edge.first] = distance + edge.second;
                pq.push({-distances[edge.first], edge.first});
            }
        }
    }
    return distances;
}
 
int path_finding_dfs(const vector<vector<pair<int, int>>> &connections, vector<bool> &visited,
                     const int start, const int target, const int min_capacity, vector<int> &path_reversed)
{
    const int FOUND = INT_MAX; // larger than 10^9 - maybe adapt
    const int NOT_FOUND = -1;
 
    // cout << "DFS: " << start << "\n";
 
    visited[start] = true;
    if (start == target)
    {
        path_reversed.push_back(target);
        return FOUND;
    }
    for (pair<int, int> edge : connections[start])
    {
        int neighbor = edge.first;
        int capacity = edge.second;
 
        if (!visited[neighbor] && capacity >= min_capacity)
        {
            int dfs_result = path_finding_dfs(connections, visited, neighbor, target, min_capacity, path_reversed);
            if (dfs_result > 0)
            {
                path_reversed.push_back(start);
                return min(dfs_result, capacity);
            }
        }
    }
    return NOT_FOUND;
}
 
int ford_fulkerson(vector<vector<pair<int, int>>> &residual_graph,
                   const int source, const int target, int starting_capacity)
{
    int n = residual_graph.size();
    int min_capacity = starting_capacity;
    int flow = 0;
    while (min_capacity > 0)
    {
        vector<int> path_reversed;
        vector<bool> visited(n, false);
 
        // cout << "Starting DFS with capacity: " << min_capacity << "\n";
        int path_capacity = path_finding_dfs(residual_graph, visited, source, target, min_capacity, path_reversed);
 
        if (path_capacity < 0)
        {
            min_capacity /= 2;
            continue;
        }
 
        flow += path_capacity;
        for (int i = 1; i < path_reversed.size(); i++)
        {
            int edge_end = path_reversed[i - 1];
            int edge_start = path_reversed[i];
            // reduce forwards edge
            for (pair<int, int> &edge : residual_graph[edge_start])
            {
                if (edge.first == edge_end)
                {
                    edge.second -= path_capacity;
                    break;
                }
            }
            // add to backwards edge
            for (pair<int, int> &edge : residual_graph[edge_end])
            {
                if (edge.first == edge_start)
                {
                    edge.second += path_capacity;
                    break;
                }
            }
        }
    }
    return flow;
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n, m;
    cin >> n >> m;
 
    vector<vector<pair<int, int>>> connections(n + 1, vector<pair<int, int>>(0));
    int max_capacity = 0;
    for (int i = 1; i <= m; i++)
    {
        int start, end, capacity;
        cin >> start >> end >> capacity;
        connections[start].push_back({end, capacity});
        connections[end].push_back({start, 0});
        if (capacity > max_capacity)
        {
            max_capacity = capacity;
        }
    }
    cout << ford_fulkerson(connections, 1, n, max_capacity) << endl;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: TIME LIMIT EXCEEDED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: TIME LIMIT EXCEEDED

Test 12

Verdict: ACCEPTED