Транспортная задача

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include<fstream.h>
#include<process.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int N,M;//Размерность задачи
float *a;  //адрес массива запасов поставщиков
float *b;  //адрес массива потребностей потребителей
float **C; //адрес массива(двумерного) стоимости перевозки
float **X;//адрес массива(двумерного) плана доставки
float *u;//адрес массива потенциалов поставщиков
float *v;//адрес массива потенциалов потребителей
float **D;//адрес массива(двумерного) оценок свободных ячеек таблицы
bool stop;//признак достижения оптимального плана
bool **T;//массив будет хранить коодинаты ячеек, в коорые уже вписывались
 //нулевые поставки при попытках устранить вырожденность плана
bool ok;
//---------------------------------------------------------------------------
           //Конструктор формы
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
          //Клик на меню "Файл->Открыть"
void __fastcall TForm1::N2Click(TObject *Sender)
{
    if(OpenDialog1->Execute())
    {
      AnsiString namefaile=OpenDialog1->FileName;//имя открываемого файла
      ifstream input(namefaile.c_str());//открытие файлового потока,связанного
  // с именем файла namefaile, которое указано в диалоговом окне "Открыть"
 
      if(!input) //если файл не найден:
       {
         ShowMessage("Ошибка открытия файла");
       }
      else //если файл найден:
       {
         int n;
         input>>n;//считываем из файла кол-во поставщиков
         StringGrid1->RowCount=n+1;//выставляем кол-во строк таблицы
         StringGrid2->RowCount=n+1;
 
         int m;
         input>>m;//считываем из файла кол-во потребителей
         StringGrid1->ColCount=m+1;//выставляем кол-во столбцов таблицы
         StringGrid3->ColCount=m+1;
         float a;
         for(int i=1;i<=n;i++)
          {
           input>>a;//считываем запасы поставщиков
           StringGrid2->Cells[0][i]=a;//заносим в таблицу
           StringGrid1->Cells[0][i]="   A"+IntToStr(i);
          }
         float b;
         for(int i=1;i<=m;i++)
          {
           input>>b;//считываем потребности потребителей
           StringGrid3->Cells[i][0]=b;//заносим в таблицу
           StringGrid1->Cells[i][0]="    B"+IntToStr(i);
          }
 
         float c;
         for(int i=1;i<=n;i++)
          for(int j=1;j<=m;j++)
           {
            input>>c;//считываем стоимость перевозки от i-го поставщика j-му потребителю
            StringGrid1->Cells[j][i]=c;//заносим в таблицу
           }
 
       }
    }
}
//---------------------------------------------------------------------------
         //Событие "Активация формы"
void __fastcall TForm1::FormActivate(TObject *Sender)
{
    StringGrid2->Cells[0][0]="Запасы:";
    StringGrid3->Cells[0][0]="Потребности:";
    Edit1->Text="Запасы\\ Потребности";
    for(int i=1;i<StringGrid1->ColCount;i++)
       StringGrid1->Cells[i][0]="     B"+IntToStr(i);
    for(int i=1;i<StringGrid1->RowCount;i++)
       StringGrid1->Cells[0][i]="     A"+IntToStr(i);
    Memo1->Clear();
}
//---------------------------------------------------------------------------
        //Клик на кнопке "Рассчитать"
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{
     Memo1->Clear();
     
     int n=StringGrid1->RowCount-1;//кол-во строк таблицы стоимости
     int m=StringGrid1->ColCount-1;//кол-во столбцов таблицы стоимости
 
     //-------------------Проверка на закрытость:
   float Sa=0;
   float Sb=0;
   try
   {
 
     for(int i=1;i<=n;i++)//находим суммарные запасы
       Sa=Sa+StrToFloat(StringGrid2->Cells[0][i]);
 
 
     for(int i=1;i<=m;i++)//находим суммарную потребность
       Sb=Sb+StrToFloat(StringGrid3->Cells[i][0]);
 
     Edit1->Text="SAj="+FloatToStr(Sa)+ " \\ SBi=" +FloatToStr(Sb);
     if(Sa==Sb)ShowMessage("Транспортная задача - закрытая");
     else
     {
        ShowMessage("Транспортная задача - открытая");
 
        if(Sa>Sb)
         {
           ShowMessage("Преобразуем задачу в закрытую\n         путём добавления\n   фиктивного потребителя B"+IntToStr(m+1));
 
             m++;
             StringGrid1->ColCount++;
             StringGrid1->Cells[m][0]="    B"+IntToStr(m);//заполняем "шапку" над добавленным столбцом
             for(int i=1;i<=n;i++)
                   StringGrid1->Cells[m][i]=0;//стоимость перевозки фиктивному потребителю равна нулю
             StringGrid3->ColCount++;
             StringGrid3->Cells[m][0]=Sa-Sb;//спрос фиктивного потребителя
           }
        else
         {
           ShowMessage("Преобразуем задачу в закрытую\n         путём добавления\n   фиктивного поставщика A"+IntToStr(n+1));
             n++;
             StringGrid1->RowCount++;
             StringGrid1->Cells[0][n]="    A"+IntToStr(n);//заполняем название добавленной строки
             for(int i=1;i<=m;i++)
                   StringGrid1->Cells[i][n]=0;//стоимость перевозки от фиктивного поставщика равна нулю
             StringGrid2->RowCount++;
             StringGrid2->Cells[0][n]=Sb-Sa;//запас фиктивного поставщика
          }
       }
     }catch(...)
      {
       ShowMessage("            Ошибка ввода данных\n Проверьте правильность заполнения таблиц");
       
      }
 
     //----------------------Инициализация динамических массивов:
          
        //запоминаем размерность в глобальных переменных:
        N=n;//кол-во строк (поставщиков)
        M=m;//кол-во столбцов (потребителей)
 
        //выделение памяти под динамические массивы и их заполнение:
        a=new float[N]; //массив для Запасов
        for(int i=0;i<N;i++)
           a[i]=StrToFloat(StringGrid2->Cells[0][i+1]);
 
        b=new float[M];//Массив для Потребностей
        for(int i=0;i<M;i++)
          b[i]=StrToFloat(StringGrid3->Cells[i+1][0]);
 
        //Двумерный массив для Стоимости:
        C=new float*[N];//выделяем память под массив адресов начала строк
        for(int i=0;i<N;i++)
           C[i]=new float[M];//выделяем память для каждой строки
 
        for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
               //Заполняем массив значениями из таблицы на форме:
                C[i][j]=StrToFloat(StringGrid1->Cells[j+1][i+1]);
 
        //Двумерный массив для Доставки:
        X=new float*[N+1];//выделяем память под массив адресов начала строк
        for(int i=0;i<N+1;i++)
           X[i]=new float[M+1];//выделяем память для каждой строки
       /*
        В последней строке(столбце) массива Х будем записывать
        сумму заполненных клеток в соответствующем столбце(строке)
       */
        for(int i=0;i<N+1;i++)
          for(int j=0;j<M+1;j++)
            {
               X[i][j]=-1;//вначале все клетки не заполнены
               if(i==N)X[i][j]=0;//сумма заполненных клеток в j-м столбце
               if(j==M)X[i][j]=0;//сумма заполненных клеток в i-й строке
            }
 
 
    //-----------------Метод минимального элемента:
 
        float Sij=0;
        do
        {
           int im;
           int jm;
           int Cmin=-1;
           for(int i=0;i<N;i++)
             for(int j=0;j<M;j++)
               if(X[N][j]!=b[j])//если не исчерпана Потребность Bj
                 if(X[i][M]!=a[i])//если не исчерпан Запас Аі
                    if(X[i][j]<0)//если клетка ещё не заполнена
                      {
                        if(Cmin==-1)//если это первая подходящая ячейка
                           {
                            Cmin=C[i][j];
                            im=i;
                            jm=j;
                           }
                        else //если это не первая подходящая ячейка
                          if(C[i][j]<Cmin)//если в ячейке меньше,чем уже найдено
                            {
                              Cmin=C[i][j];
                              im=i;
                              jm=j;
                             }
                        }
 
               X[im][jm]=min(a[im]-X[im][M],b[jm]-X[N][jm]);//выбираем поставку
               X[N][jm]=X[N][jm]+X[im][jm];//добавляем поставку jm-му потребителю
               X[im][M]=X[im][M]+X[im][jm];//добавляем поставку im-му поставщику
               Sij=Sij+X[im][jm]; //Подсчёт суммы добавленых поставок
 
        }while(Sij<max(Sa,Sb));//условие продолжения
 
        int L=0;
        for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
            if(X[i][j]>=0)L++;//подсчёт заполненных ячеек
        int d=M+N-1-L;//если d>0,то задача - вырожденная,придётся добавлять d нулевых поставок
        int d1=d;//запоминаем значение d
 
       Memo1->Lines->Add("Начальный опорный план:");
       Memo1->Lines->Add("");
       Memo1->Lines->Add("");
       int F=0;
       for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
            {
              Memo1->Text=Memo1->Text+FloatToStr(X[i][j])+"    ";
              if(X[i][j]>0)F=F+X[i][j]*C[i][j];
              if(j==M-1)Memo1->Lines->Add("");
            }
       Memo1->Lines->Add("--------");
       Memo1->Lines->Add("F="+FloatToStr(F));
       ShowMessage("Для продолжения нажмите \"ОК\" ");
 
       
   //--------------------------Метод потенциалов
 
    T=new bool*[N];
    for(int i=0;i<N;i++)
        T[i]=new bool[M];
    for(int i=0;i<N;i++)
       for(int j=0;j<M;j++)
            T[i][j]=false;
 
    do{//цикл поиска оптимального решения
 
       stop=true;//признак оптимальности плана(после проверки может стать false)
       u=new float[N];//выделение массивов под значения потециалов
       v=new float[M];
       bool *ub=new bool[N];//вспомогательные массвы
       bool *vb=new bool[M];
       for(int i=0;i<N;i++)ub[i]=false;
       for(int i=0;i<M;i++)vb[i]=false;
 
 
            //цикл расчёта потенциалов (несколько избыточен):
       u[0]=0;//значение одного потенциала выбираем произвольно
       ub[0]=true;
       int count=1;
       int tmp=0;
       do{
            for(int i=0;i<N;i++)
              if(ub[i]==true)
                for(int j=0;j<M;j++)
                  if(X[i][j]>=0)
                    if(vb[j]==false)
                      {
                        v[j]=C[i][j]-u[i];
                        vb[j]=true;
                        count++;
                      }
           for(int j=0;j<M;j++)
             if(vb[j]==true)
               for(int i=0;i<N;i++)
                 if(X[i][j]>=0)
                   if(ub[i]==false)
                     {
                       u[i]=C[i][j]-v[j];
                       ub[i]=true;
                       count++;
                     }
 
 
          tmp++;
         }while((count<(M+N-d*2))&&(tmp<M*N));
        Memo1->Lines->Add("--------");
 
 
         //цикл добавления нулевых поставок(в случае вырожденности):
        bool t=false;
 
        if((d>0)||ok==false)t=true;//цикл начинается, если d>0
        while(t)//цикл продолжается до тех пор, пока все потенциалы не будут найдены
          {
           for(int i=0;(i<N);i++)//просматриваем потенциалы поставщиков
             if(ub[i]==false)//если среди них не заполненный потенциал
               for(int j=0;(j<M);j++)
                 if(vb[j]==true)
                  {
                    if(d>0)
                     if(T[i][j]==false)//если раньше не пытались использовать
                      {
                        X[i][j]=0;//добавляем нулевую поставку
                        d--;//уменьшаем кол-во требуемых добавлений нулевых поставок
                        T[i][j]=true;//отмечаем, что эту ячейку уже использовали
                      }
                    if(X[i][j]>=0)
                      {
                         u[i]=C[i][j]-v[j];//дозаполняем потенциалы
                         ub[i]=true;
                      }
                  }
           for(int j=0;(j<M);j++)//просматриваем потенциалы потребителей
             if(vb[j]==false)//если среди них не заполненный потенциал
               for(int i=0;(i<N);i++)
                 if(ub[i]==true)
                  {
                    if(d>0)
                      if(T[i][j]==false)//если раньше не пытались использовать
                      {
                        X[i][j]=0;//добавляем нулевую поставку
                        d--;//уменьшаем кол-во требуемых добавлений нулевых поставок
                        T[i][j]=true;//отмечаем, что эту ячейку уже использовали
                      }
                    if(X[i][j]>=0)
                     {
                        v[j]=C[i][j]-u[i];//дозаполняем потенциалы
                        vb[j]=true;
                     }
                  }
              t=false; //проверяем, все ли потенциалы найдены
              for(int i=0;i<N;i++)
                if(ub[i]==false)t=true;
              for(int j=0;j<M;j++)
                if(vb[j]==false)t=true;
 
             if(t==false)
             {
               Memo1->Lines->Add("Опорный план после устранения вырожденности:");
               Memo1->Lines->Add("");
               for(int i=0;i<N;i++)
                  for(int j=0;j<M;j++)
                   {
                     Memo1->Text=Memo1->Text+FloatToStr(X[i][j])+"    ";
                     if(j==M-1)Memo1->Lines->Add("");
                   }
               Memo1->Lines->Add("--------");
               //ShowMessage("Для продолжения нажмите \"ОК\" ");
              }
 
           }
        //-----------
 
       Memo1->Lines->Add("Потенциалы:");
       Memo1->Lines->Add("u: ");
       for(int i=0;i<N;i++)
           Memo1->Text=Memo1->Text+FloatToStr(u[i])+"    ";
       Memo1->Lines->Add("v: ");
       Memo1->Lines->Add("");
       for(int i=0;i<M;i++)
           Memo1->Text=Memo1->Text+FloatToStr(v[i])+"    ";
 
       Memo1->Lines->Add("--------");
       //ShowMessage("Для продолжения нажмите \"ОК\" ");
 
        //----------------------
 
        D=new float*[N];//выделяем память под массив оценок свободных ячеек
        for(int i=0;i<N;i++)
           D[i]=new float[M];
 
        //int Dmin=0;
        //int im=-1;
        //int jm=-1;
        for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
           {
              if(X[i][j]>=0)//если ячейка не свободна
                    D[i][j]=88;//Заполняем любыми положительными числами
              else  //если ячейка свободна
                    D[i][j]=C[i][j]-u[i]-v[j];//находим оценку
 
              if(D[i][j]<0)
                 {
                    //Dmin=D[i][j];//запоминаем оценку
                    //im=i; //координаты клетки
                    //jm=j;
                    stop=false;//признак того, что план не оптимальный
                  }
 
            }
       //
      Memo1->Lines->Add("Матрица оценок свободных ячеек (если ячейка занята - ставим 88)");
      Memo1->Lines->Add("");
      for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
            {
 
              Memo1->Text=Memo1->Text+FloatToStr(D[i][j])+"     ";
              if(j==M-1)Memo1->Lines->Add("");
             }
       Memo1->Lines->Add("--------");
       //
       ShowMessage("Для продолжения нажмите \"ОК\" ");
       if(stop==false)//если план не оптимальный
         {
            float **Y=new float*[N];//массив для хранения цикла перераспределения поставок
            for(int i=0;i<N;i++)
              Y[i]=new float[M];
 
 
 
            float find1,find2;//величина перераспределения поставки для цикла
            float best1=0;//наилучшая оценка улучшения среди всех допустимых перераспределений
            float best2=0;
            int ib1=-1;
            int jb1=-1;
            int ib2=-1;
            int jb2=-1;
            //Ищем наилучший цикл перераспределения поставок:
            for(int i=0;i<N;i++)
             for(int j=0;j<M;j++)
              if(D[i][j]<0)//Идём по ВСЕМ ячейкам с отрицательной оценкой
                {  //и ищем допустимые циклы перераспределения ДЛЯ КАЖДОЙ такой ячейки
                    //Обнуляем матрицу Y:
                    for(int i=0;i<N;i++)
                     for(int j=0;j<M;j++)
                       Y[i][j]=0;
                    //Ищем цикл для ячейки с оценкой D[i][j]:
                    find1=find_gor(i,j,i,j,N,M,X,Y,0,-1);//Начинаем идти по горизонтали
 
                     //Обнуляем матрицу Y:
                    for(int i=0;i<N;i++)
                     for(int j=0;j<M;j++)
                       Y[i][j]=0;
                    find2=find_ver(i,j,i,j,N,M,X,Y,0,-1);//Начинаем по вертикали
 
                    if(find1>0)
                      if(best1>D[i][j]*find1)
                         {
                            best1=D[i][j]*find1;//наилучшая оценка
                            ib1=i;//запомминаем координаты ячейки
                            jb1=j;//цикл из которой даёт наибольшее улучшение
                         }
                    if(find2>0)
                      if(best2>D[i][j]*find2)
                         {
                            best2=D[i][j]*find2;//наилучшая оценка
                            ib2=i;//запомминаем координаты ячейки
                            jb2=j;//цикл из которой даёт наибольшее улучшение
                         }
                 }
             if((best1==0)&&(best2==0))
             {
               //stop=true;
               //ShowMessage("Цикл перераспределения поставок не найден");
               ok=false;
               d=d1;//откат назад
               for(int i=0;i<N;i++)
                for(int j=0;j<M;j++)
                  if(X[i][j]==0)X[i][j]=-1;
               continue;
             }
            else
            {   //Обнуляем матрицу Y:
                for(int i=0;i<N;i++)
                     for(int j=0;j<M;j++)
                       Y[i][j]=0;
               //возвращаемся к вычислению цикла с наилучшим перераспределением:
               int ib,jb;
               if(best1<best2)
                   {
                     find_gor(ib1,jb1,ib1,jb1,N,M,X,Y,0,-1);
                     ib=ib1;
                     jb=jb1;
                   }
               else
                   {
                      find_ver(ib2,jb2,ib2,jb2,N,M,X,Y,0,-1);
                      ib=ib2;
                      jb=jb2;
                   }
               for(int i=0;i<N;i++)
                {
                  for(int j=0;j<M;j++)
                   {
                    if( (X[i][j]==0)&&(Y[i][j]<0) )
                       {
                         stop=true;
                         ok=false;
                         d=d1;//откат назад
                         Memo1->Lines->Add("Попытка отрицательной поставки!");
                         //ShowMessage("Попытка отрицательной поставки!");
                         //break;
                        }
                    X[i][j]= X[i][j]+Y[i][j];//перераспределяем поставки
                    if((i==ib)&&(j==jb))X[i][j]=X[i][j]+1;//добавляем 1 (т.к. до этого было -1 )
                    if((Y[i][j]<=0)&&(X[i][j]==0))X[i][j]=-1;//если ячейка обнулилась, то выбрасываем её из рассмотрения
                   }
                  //if(stop)break;
                }
              }
           //
          Memo1->Lines->Add("Матрица цикла перерасчёта:");
          Memo1->Lines->Add("");
          for(int i=0;i<N;i++)
           for(int j=0;j<M;j++)
            {
              Memo1->Text=Memo1->Text+FloatToStr(Y[i][j])+"    ";
              if(j==M-1)Memo1->Lines->Add("");
             }
           Memo1->Lines->Add("--------");
           //ShowMessage("Для продолжения нажмите \"ОК\" ");
 
          Memo1->Lines->Add("Новый план:");
          Memo1->Lines->Add("");
          float F=0;
          for(int i=0;i<N;i++)
           for(int j=0;j<M;j++)
            {
              Memo1->Text=Memo1->Text+FloatToStr(X[i][j])+"    ";
              if(X[i][j]>0)F=F+X[i][j]*C[i][j];
              if(j==M-1)Memo1->Lines->Add("");
             }
           Memo1->Lines->Add("F="+FloatToStr(F));
           Memo1->Lines->Add("--------");
           ShowMessage("Для продолжения нажмите \"ОК\" ");
           //
 
           ok=true;
           for(int i=0;i<N;i++)
             for(int j=0;j<M;j++)
               T[i][j]=false;
 
 
            delete []Y;
 
            //проверка на вырожденность: (?)
           L=0;
           for(int i=0;i<N;i++)
             for(int j=0;j<M;j++)
               if(X[i][j]>=0)L++;//подсчёт заполненных ячеек
            d=M+N-1-L;//если d>0,то задача - вырожденная
            d1=d;
            if(d>0)ok=false;
 
          }
 
          delete []u;
          delete []v;
          delete []ub;
          delete []vb;
          delete []D;
 
 
       }while(stop==false);
 
     Memo1->Lines->Add("Оптимальный план:");
     Memo1->Lines->Add("");
     float Fmin=0;
     for(int i=0;i<N;i++)
          for(int j=0;j<M;j++)
            {
              Memo1->Text=Memo1->Text+FloatToStr(X[i][j])+"    ";
              if(X[i][j]>0)Fmin=Fmin+X[i][j]*C[i][j];
              if(j==M-1)Memo1->Lines->Add("");
             }
     Memo1->Lines->Add("Fmin="+FloatToStr(Fmin));
 
      delete []X;
      delete []C;
      delete []a;
      delete []b;
}
//---------------------------------------------------------------------------
     //Функуция поиска ячеек,подлежащих циклу перераспределения (вдоль строки)
float TForm1::find_gor(int i_next,int j_next,int im,int jm,int n,int m,float** X,float** Y,int odd,float Xmin)
{
   int rez=-1;
   for(int j=0;j<m;j++)//идём вдоль строки, на которой стоим
 //ищем заполненную ячейку(кроме той,где стоим) или начальная ячейка(но уже в конце цикла:odd!=0 )
     if(((X[i_next][j]>=0)&&(j!=j_next))||((j==jm)&&(i_next==im)&&(odd!=0)))
       {
         odd++;//номер ячейки в цикле перерасчёта(начало с нуля)
         if(odd>1000)
           {
              ShowMessage("Угроза переполнения стека");
              return -1;
           }
         int Xmin_old=-1;
         if((odd%2)==1)//если ячейка нечётная в цикле ( начальная- нулевая )
          {
           Xmin_old=Xmin;//Запоминаем значение минимальной поставки в цикле (на случай отката назад)
           if(Xmin<0)Xmin=X[i_next][j];//если это первая встреченная ненулевая ячейка
           else if((X[i_next][j]<Xmin)&&(X[i_next][j]>=0))
                     {
                       Xmin=X[i_next][j];
                       
                     }
          }
         if((j==jm)&&(i_next==im)&&((odd%2)==0))//если замкнулся круг и цикл имеет чётное число ячеек
           {
             Y[im][jm]= Xmin;//Значение минимальной поставки, на величину которой будем изменять
             return Xmin;
            }
           //если круг еще не замкнулся - переходим к поиску по вертикали:
         else rez=find_ver(i_next,j,im,jm,n,m,X,Y,odd,Xmin);//рекурсивный вызов
         if(rez>=0)//как бы обратный ход рекурсии(в случае если круг замкнулся)
            {
              //для каждой ячейки цикла заполняем матрицу перерасчёта поставок:
              if(odd%2==0)Y[i_next][j]=Y[im][jm];//в чётных узлах прибавляем
              else  Y[i_next][j]=-Y[im][jm];//в нечётных узлах вычитаем
              break;
            }
         else //откат назад в случае неудачи(круг не замкнулся):
           {
             odd--;
             if(Xmin_old>=0)//если мы изменяли Xmin на этой итерации
                Xmin=Xmin_old;
           }
       }
 
   return rez;//если круг замкнулся (вернулись в исходную за чётное число шагов) -
   // возвращает найденное минимальное значение поставки в нечётных ячейках цикла,
   // если круг не замкнулся, то возвращает -1.
}
//-----------------------------------------------------------------------------
    //Функуция поиска ячеек,подлежащих циклу перераспределения (вдоль столбца)
float TForm1::find_ver(int i_next,int j_next,int im,int jm,int n,int m,float** X,float** Y,int odd,float Xmin)
{
   int rez=-1;
   int i;
   for(i=0;i<n;i++)//идём вдоль столбца, на котором стоим
 //ищем заполненную ячейку(кроме той,где стоим) или начальная ячейка(но уже в конце цикла:odd!=0 )
     if(((X[i][j_next]>=0))&&(i!=i_next)||((j_next==jm)&&(i==im)&&(odd!=0)))
       {
         odd++;//номер ячейки в цикле перерасчёта(начало с нуля)
         if(odd>1000)
           {
              ShowMessage("Угроза переполнения стека");
              return -1;
           }
         int Xmin_old=-1;
         if((odd%2)==1)//если ячейка нечётная в цикле ( начальная- нулевая )
          {
            Xmin_old=Xmin;//Запоминаем значение минимальной поставки в цикле (на случай отката назад)
            if(Xmin<0)Xmin=X[i][j_next];//если это первая встреченная ненулевая ячейка
            else if((X[i][j_next]<Xmin)&&(X[i][j_next]>=0))
                       Xmin=X[i][j_next];
 
 
          }
         if((i==im)&&(j_next==jm)&&((odd%2)==0))//если замкнулся круг и цикл имеет чётное число ячеек
            {
              Y[im][jm]= Xmin;//Значение минимальной поставки, на величину которой будем изменять
              return Xmin;
            }
            //если круг еще не замкнулся - переходим к поиску по горизонтали:
         else rez=find_gor(i,j_next,im,jm,n,m,X,Y,odd,Xmin);//- рекурсивный вызов
         if(rez>=0)//как бы обратный ход (в случае если круг замкнулся)
            {
              //для каждой ячейки цикла заполняем матрицу перерасчёта поставок:
              if(odd%2==0)Y[i][j_next]=Y[im][jm];//эти прибавляются
              else  Y[i][j_next]=-Y[im][jm];//эти вычитаются
              break;
            }
         else //откат назад в случае неудачи (круг не замкнулся):
           {
             odd--;
             if(Xmin_old>=0)//если мы изменяли Xmin на этой итерации
                Xmin=Xmin_old;
           }
       }
 
   return rez;
}
//---------------------------------------------------------------------------
            //Добавление строк
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{
    StringGrid1->RowCount++;
    StringGrid2->RowCount++;
    for(int i=1;i<StringGrid1->RowCount;i++)
       StringGrid1->Cells[0][i]="     A"+IntToStr(i);
}
//---------------------------------------------------------------------------
           //Уменьшение кол-ва строк
void __fastcall TForm1::BitBtn3Click(TObject *Sender)
{
   if(StringGrid1->RowCount>3)
   {
    StringGrid1->RowCount--;
    StringGrid2->RowCount--;
    for(int i=1;i<StringGrid1->RowCount;i++)
       StringGrid1->Cells[0][i]="     A"+IntToStr(i);
   }    
}
//---------------------------------------------------------------------------
           //Добавление столюцов
void __fastcall TForm1::BitBtn4Click(TObject *Sender)
{
    StringGrid1->ColCount++;
    StringGrid3->ColCount++;
    for(int i=1;i<StringGrid1->ColCount;i++)
       StringGrid1->Cells[i][0]="     B"+IntToStr(i);
}
//---------------------------------------------------------------------------
          //Уменьшение кол-ва столбцов
void __fastcall TForm1::BitBtn5Click(TObject *Sender)
{
    StringGrid1->ColCount--;
    StringGrid3->ColCount--;
    for(int i=1;i<StringGrid1->ColCount;i++)
       StringGrid1->Cells[i][0]="     B"+IntToStr(i);
}
//---------------------------------------------------------------------------
         //Клик на меню "Файл ->Сохраниить как..."
void __fastcall TForm1::N3Click(TObject *Sender)
{
  if(SaveDialog1->Execute())
  {
      Memo1->Lines->SaveToFile(SaveDialog1->FileName+".txt");
  }    
}