C++ MAXFLOW-MINCUT代码中存在错误

我已经使用edmonds karp实现编写了一个Max Flow类。当我尝试获取最大流的值时，代码似乎工作正常。我在SPOJ上提交了代码，所以我相信实现是正确的

但是我试图从残差图中得到最小割。这导致了一些错误。任何帮助都是有用的

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

class EdmondsKarp
{
private:
    vector<vector<int>> graph;
    vector<vector<int>> rGraph;
    vector<vector<int>> capacities;
    vector<int> parent;
    vector<bool> visited;
    int source, sink;
    int flow;
public:
    EdmondsKarp(vector<vector<int>> graph, vector<vector<int>> capacities, int source, int sink)
    {
        this->graph = graph;
        this->capacities = capacities;
        this->rGraph = capacities;
        this->source = source;
        this->sink = sink;
        parent.resize(rGraph.size());
        visited.resize(rGraph.size());
        makeFlow();
    }
    bool bfs()
    {
        for (int i = 0; i < visited.size(); i++)
        {
            visited[i] = false;
        }

        queue<int> q;
        visited[source] = true;
        parent[source] = -1;
        q.push(source);
        int qf, v;
        while (!q.empty())
        {
            qf = q.front();
            q.pop();
            for (int i = 0; i < graph[qf].size(); i++)
            {
                v = graph[qf][i];
                if (!visited[v] && rGraph[qf][v] > 0)
                {
                    q.push(v);
                    parent[v] = qf;
                    visited[v] = true;
                }
            }
        }
        return visited[sink];
    }

    int makeFlow()
    {
        int INF = 9 + 1e9;
        flow = 0;
        int u, v, path_flow;
        while (bfs())
        {
            path_flow = INF;
            for (v = sink; v != source; v = parent[v])
            {
                u = parent[v];
                path_flow = min(path_flow, rGraph[u][v]);
            }

            for (v = sink; v != source; v = parent[v])
            {
                u = parent[v];
                rGraph[u][v] -= path_flow;
                rGraph[v][u] += path_flow;
            }
            flow += path_flow;
        }
        return 1;
    }

    int getFlow()
    {
        return flow;
    }

    vector<vector<int>> getFlowGraph()
    {
        vector<vector<int>> flowGraph(capacities.size(), vector<int>(capacities.size(), 0));
        for (int i = 0; i < capacities.size(); i++)
        {
            for (int j = 0; j < capacities[i].size(); j++)
            {
                if (capacities[i][j] > 0)
                {
                    flowGraph[i][j] = capacities[i][j] - rGraph[i][j];
                }
            }
        }
        return flowGraph;
    }

    vector<int> getMinCut()
    {
        vector<int> cut;
        bfs();
        int cutsize = 0;
        for (int i = 0; i < visited.size(); i++)
        {
            if (visited[i])
            {
                cut.push_back(i);
                for (int j = 0; j < graph[i].size(); j++)
                {
                    if (!visited[graph[i][j]])
                    {
                        cutsize += capacities[i][graph[i][j]];
                    }
                }
            }
        }
        cout << cutsize << endl;
        return cut;
    }
};

#包括
#包括
#包括
使用名称空间std；
埃德蒙斯卡普级
{
私人：
矢量图；
矢量图形；
媒介容量；
载体亲本；
访问的病媒；
int源、汇；
int流；
公众：
EdmondsKarp（矢量图、矢量容量、整数源、整数汇）
{
这个->图=图；
这->容量=容量；
这->rGraph=容量；
此->源=源；
这个->水槽=水槽；
resize（rGraph.size（））；
resize（rGraph.size（））；
makeFlow（）；
}
布尔bfs（）
{
对于（int i=0；i0）
{
q、 推（v）；
母公司[v]=qf；
访问[v]=正确；
}
}
}
回访[沉没]；
}
int makeFlow（）
{
int INF=9+1e9；
流量=0；
int u，v，路径u流；
while（bfs（））
{
路径_流量=INF；
对于（v=sink；v！=source；v=parent[v]）
{
u=父项[v]；
路径流量=最小值（路径流量，rGraph[u][v]）；
}
对于（v=sink；v！=source；v=parent[v]）
{
u=父项[v]；
rGraph[u][v]=路径流；
rGraph[v][u]+=路径流；
}
流量+=路径\流量；
}
返回1；
}
int getFlow（）
{
回流；
}
向量getFlowGraph（）
{
向量流程图（capacities.size（），向量（capacities.size（），0））；
对于（int i=0；i0）
{
流程图[i][j]=容量[i][j]-rGraph[i][j]；
}
}
}
返回流程图；
}
向量getMinCut（）
{
矢量切割；
bfs（）；
int cutsize=0；
对于（int i=0；i>x>>y>>w；
图[x]。推回（y）；
容量[x][y]+=w；
图[y]。推回（x）；
容量[y][x]+=w；
}
EdmondsKarp edk（图形，容量，'A'，'Z'）；
edk.getMinCut（）；
}

因此，我设法修复了getMinCut函数。不幸的是，我没有找出原始代码中的错误。我也没有运行所有可能的边组合，并将适当的边添加到剪切中

vector<int> getMinCut()
{
  vector<int> cut;
  bfs();
  for (int i = 0; i < visited.size(); i++)
  {
    if(visited[i])
    {
      cut.push_back(i);
    }
  }
  int cutsize = 0;
  for (int i = 0; i < graph.size(); i++)
  {
    for (int j = 0; j < graph.size(); j++)
    {
      if(visited[i] && !visited[j])
      {
        cutsize += capacities[i][j];
      }
    }
  }
  cout << cutsize << endl;
  return cut;
}

向量getMinCut（） { 矢量切割； bfs（）； 对于（int i=0；icout“导致了一些错误”有点泛化，也许你应该详细说明修改语句。我的意思是cutsize的值是错误的。它没有给我正确的答案。输入什么？你收到的值是多少？你期望得到什么？请将这些添加到你的问题中，并尝试找到重现此问题的最简单示例J没有给出测试数据。因此我无法找到正确的测试用例。我尝试生成5-6个小测试用例，但无法找到差异。

vector<int> getMinCut()
{
  vector<int> cut;
  bfs();
  for (int i = 0; i < visited.size(); i++)
  {
    if(visited[i])
    {
      cut.push_back(i);
    }
  }
  int cutsize = 0;
  for (int i = 0; i < graph.size(); i++)
  {
    for (int j = 0; j < graph.size(); j++)
    {
      if(visited[i] && !visited[j])
      {
        cutsize += capacities[i][j];
      }
    }
  }
  cout << cutsize << endl;
  return cut;
}