Алгоритм Эдмондса-Карпа

#include<queue>
#include<cstring>
#include<vector>
#include<iostream>
#include<fstream>
using namespace std;
int c[10][10];
int flowPassed[10][10];
vector<int> g[10];
int parList[10];
int currentPathC[10];

int bfs(int source, int sink)//поиск в ширину
{
    memset(parList, -1, sizeof(parList));
    memset(currentPathC, 0, sizeof(currentPathC));
    queue<int> q;//очередь
    q.push(source);
    parList[source] = -1;//инициализируем исходный узел parlist
    currentPathC[source] = 999;//инициализируем исходный узел currentpath
    while (!q.empty())// если очередь не пуста
    {
        int currNode = q.front();//берем первый элемент очереди
        q.pop();//удаляем из очереди
        for (int i = 0; i < g[currNode].size(); i++)
        {
            int to = g[currNode][i];//берем смежную с текущей вершину
            if (parList[to] == -1)//если вершина помечена 
            {
                if (c[currNode][to] - flowPassed[currNode][to] > 0)//остаточная пропускная способность положительна
                {
                    parList[to] = currNode;
                    currentPathC[to] = min(currentPathC[currNode], c[currNode][to] - flowPassed[currNode][to]);//находим наименьшую остаточную пропускную способность
                    if (to == sink)
                    {
                      
                        return currentPathC[sink];
                    }
                    q.push(to);
                }
            }
        }
    }
    return 0;
}
int edmondsKarp(int source, int sink)
{
    int maxFlow = 0;
    while (true)
    {
        int flow = bfs(source, sink);
        if (flow == 0)//если поток 0,то выходим
        {
            break;
        }
        maxFlow += flow;
        int currNode = sink;
        while (currNode != source)//увеличиваем поток
        {
            int prevNode = parList[currNode];
            flowPassed[prevNode][currNode] += flow;
            flowPassed[currNode][prevNode] -= flow;
            cout <<prevNode<<" "<<currNode<<"  " <<flowPassed[prevNode][currNode] << " " << flowPassed[currNode][prevNode] << endl;
            currNode = prevNode;
        }
    }
    return maxFlow;//возвращаем макс.поток
}
int main()
{
    setlocale(LC_ALL, "Russian");
    ifstream in("input1.txt");
    int n, m;
    cout << "Введите количество узлов и ребер\n";
    in >> n >> m;
    int source, sink;
    cout << "Введите сток и исток\n";
    cin >> source >> sink;
    for (int ed = 0; ed < m; ed++)
    {
 
        int from, to, cap;
        in >> from >> to >> cap;
        c[from][to] = cap;
        g[from].push_back(to);
        g[to].push_back(from);
    }
  
    int maxFlow = edmondsKarp(source, sink);
    cout << endl << endl << "Максимальный поток: " << maxFlow << endl;
}

Нашел в интернете алгоритм Эдмондса-Карпа. Ввел такой граф:

6 9

1 2 7

1 3 4

2 4 5

2 5 3

3 2 3

3 5 2

4 6 8

5 4 3

5 6 5 Алгоритм работает правильно и поток максимальный тоже правильный. Только вот странные у него значения потоков. Либо я не до конца программу понял. Вообщем ребро 4-6 должно быть со значением 6,а 5-6 со значением 4. Выводит это:

4 6 5 -5

2 4 5 -5

1 2 5 -5

5 6 2 -2

2 5 2 -2

1 2 7 -7

5 6 4 -4

3 5 2 -2

1 3 2 -2

5 6 5 -5

2 5 3 -3

3 2 1 -1

1 3 3 -3