Обход графа в ширину - перевести код с C++

const int MAX_VERTICES = 40;
 
int NUM_VERTICES; 
const int INFINITY = 10000;
 
int f[MAX_VERTICES][MAX_VERTICES];
int c[MAX_VERTICES][MAX_VERTICES];
 
int Flow[MAX_VERTICES];
// Link используется для нахождения собственно пути
// Link[i] хранит номер предыдущей вершины на пути i -> исток
int Link[MAX_VERTICES]; 
int Queue[MAX_VERTICES]; // очередь
int QP, QC; // QP - указатель начала очереди и QC - число эл-тов в очереди
 
int FindPath(int source, int target) // source - исток, target - сток
{
        QP = 0; QC = 1; Queue[0] = source;
        Link[target] = -1; 
        int i;
        int CurVertex;
        memset(Flow, 0, sizeof(int)*NUM_VERTICES); 
        Flow[source] = INFINITY; 
        while (Link[target] == -1 && QP < QC)
        {
                CurVertex = Queue[QP];
                for (i=0; i<NUM_VERTICES; i++)
                if ((c[CurVertex][i] - f[CurVertex][i])>0 && Flow[i] == 0) 
                {
                        Queue[QC] = i; QC++;
                        Link[i] = CurVertex; 
                        if (c[CurVertex][i]-f[CurVertex][i] < Flow[CurVertex])
                             Flow[i] = c[CurVertex][i];
                        else
                             Flow[i] = Flow[CurVertex];
                }
            QP++;
        }
        if (Link[target] == -1) return 0; // мы или не находим путь и выходим
        CurVertex = target;
        while (CurVertex != source) 
        {
                f[Link[CurVertex]][CurVertex] +=Flow[target];
                CurVertex = Link[CurVertex];
        }
        return Flow[target];
}
 
int MaxFlow(int source, int target) // source - исток, target - сток
{
        // инициализируем переменные:
        memset(f, 0, sizeof(int)*MAX_VERTICES*MAX_VERTICES); 
        int MaxFlow = 0; 
        int AddFlow;
        do
        {
            
                AddFlow = FindPath(source, target);
                MaxFlow += AddFlow;
        } while (AddFlow >0);
        return MaxFlow;
}
 
int main()
 
   int source, target;
   printf(rus("\n Введите число вершин в графе\n-->"));
   scanf("%d", &NUM_VERTICES);
   printf(rus("\n Введите значения истока и стока \n-->"));
   scanf("%d %d", &source, &target);
   printf(rus("\n   Введите матрицу содержащею вместимость ребер: \n "));
   printf(rus("каждый элемент - вместимость ребра ведушего \n из вершины с номером его строки к вершине с номером его столбца\n"));
   int i, j;
      for (i=0; i<NUM_VERTICES; i++)
      for (j=0; j<NUM_VERTICES; j++)
         scanf("%d",&c[i][j]);
 
   printf(rus("\n максимальный поток равен:"));
   printf("%d", MaxFlow(source, target));
   getch();
   return 0;
}

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication1
{
     public class fulkerson 
    { 
         int MAX_VERTICES = 40;
 
        int NUM_VERTICES; // число вершин в графе
        const int INFINITY = 10000; // условное число обозначающее бесконечность
 
        int [,] f;
        int [,] c;
 
        int [] Flow;
        int [] Link; 
        int  [] Queue; 
        int QP, QC;
 
        public int findpath(int source, int target)
        {
            Flow = new int[MAX_VERTICES];
            Link = new int[MAX_VERTICES];
            Queue = new int[MAX_VERTICES];
                
 
            f = new int[MAX_VERTICES, MAX_VERTICES];
            c = new int[MAX_VERTICES, MAX_VERTICES];
            QP = 0; QC = 1; Queue[0] = source;
            Link[target] = -1; 
            int i;
            int CurVertex;
            for (i = 0; i < NUM_VERTICES; i++)
            {
                Flow[i] = 0;
                Link[i] = 0;
                Queue[i] = 0;
            }
            Flow[source] = INFINITY; // а из истока может вытечь сколько угодно
            while (Link[target] == -1 && QP < QC)
            {
                // смотрим какие вершины могут быть достигнуты из начала очереди
                CurVertex = Queue[QP];
                for (i = 0; i < NUM_VERTICES; i++)
                    // проверяем можем ли мы пустить поток по ребру (CurVertex,i):
                    if ((c[CurVertex,i] - f[CurVertex,i]) > 0 && Flow[i] == 0)
                    {
                        // если можем, то добавляем i в конец очереди
                        Queue[QC] = i; QC++;
                        Link[i] = CurVertex; // указываем, что в i добрались из CurVertex
                        // и находим значение потока текущее через вершину i
                        if (c[CurVertex,i] - f[CurVertex,i] < Flow[CurVertex])
                            Flow[i] = c[CurVertex,i];
                        else
                            Flow[i] = Flow[CurVertex];
                    }
                QP++;// прерходим к следующей в очереди вершине
            }
            if (Link[target] == -1) return 0; // мы или не находим путь и выходим
            // или находим:
            // тогда Flow[target] будет равен потоку который "дотек" по данному пути из истока в сток
            // тогда изменяем значения массива f для  данного пути на величину Flow[target]
            CurVertex = target;
            while (CurVertex != source) // путь из стока в исток мы восстанавливаем с помощбю массива Link
            {
                f[Link[CurVertex],CurVertex]+=Flow[target];
 
                CurVertex = Link[CurVertex];
            }
            return Flow[target];
        }
        public int MaxFlow(int source, int target) // source - исток, target - сток
        {
            // инициализируем переменные:
            for (int i = 0; i < NUM_VERTICES; i++)// по графу ничего не течет
            {
                for (int j = 0; j < NUM_VERTICES; j++)
                    f[i, j] = 0;
            }
            int MaxFlow = 0; // начальное значение потока
            int AddFlow=0;
            do
            {
                // каждую итерацию ищем какй-либо простой путь из истока в сток
                // и какой еще поток мажет быть пущен по этому пути
                AddFlow = findpath(source, target);
                MaxFlow += AddFlow;
            } while (AddFlow > 0);// повторяем цикл пока поток увеличивается
            return MaxFlow;
        }
    }
 
    class Program
    {
 
        static void Main(string[] args)
        {
            int source, target, NUM_VERTICES;
            Console.WriteLine("Введите размер матрицы");
            NUM_VERTICES = int.Parse(Console.ReadLine());
 
            source = int.Parse(Console.ReadLine());
            target = int.Parse(Console.ReadLine());
            
            int[,] c = new int[NUM_VERTICES, NUM_VERTICES];
            for (int i = 0; i < NUM_VERTICES; i++)
            {
                for (int j = 0; j < NUM_VERTICES; j++)
                {
                    c[i, j] = int.Parse(Console.ReadLine());
                }
            }
            fulkerson fl = new fulkerson();
            fl.MaxFlow(source, target);
            Console.WriteLine();
 
        }
    }
}