Круги, что образуют самую длинную цепь - выделить отдельным цветом, рисование на канве

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <math>
#include <vector>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#define FIELD Image1
#define COUNT 30
#define RADIUSMAX 50
#define RADIUSMIN 30
 
struct Circle_s
{
  int x;
  int y;
  int Radius;
  int Number; // Уникальный
};
 
const int CountCircles = COUNT;
Circle_s ArrCenterCircles[CountCircles];
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void Draw( Circle_s* pCurrCircle, TCanvas* pCanvas, TColor CurrColor ) // Просто функция рисования
{
  pCanvas->Brush->Style = bsClear;
  pCanvas->Pen->Color = CurrColor;
 
  int x = pCurrCircle->x,
      y = pCurrCircle->y,
      r = pCurrCircle->Radius;
  pCanvas->Ellipse( x - r, y - r, x + r, y + r );
 
  String Number = IntToStr( pCurrCircle->Number );
  pCanvas->TextOutA( x - pCanvas->TextWidth( Number )/2,
                     y - pCanvas->TextHeight( Number )/2,
                     Number );
  pCanvas->MoveTo( x, y );
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class Node_c
{
private:
  Node_c *pPrevious;                  // Один
  std::vector< Node_c* > Next;        // ко многим
  Circle_s *pCircle;
  unsigned int Metric;                // Расстояние от корня
 
public:
  Node_c( Circle_s* pNewCircle, int NewMetric )
    : pPrevious( NULL ), Next( NULL ), Metric( NewMetric ), pCircle( pNewCircle )
    {};
 
  Node_c* MakeNode( Circle_s* pNewCircle, int NewMetric )   // Создаем узел и возвращаем на него указатель
    {
    Node_c *pNewNode = new Node_c( pNewCircle, NewMetric ); // Утечка памяти
    pNewNode->pPrevious = this;
 
    Next.push_back( pNewNode );
 
    return pNewNode;
    };
 
  void FindMatchBack( Circle_s* pFindCircle, Node_c* pCurrNode, bool &Result ) // Рекурсивная функция поиска окружности в текущей ветви дерева
    {                                                                          // Ищем совпадение от текущего узла до корня и выводим результат в Result
    if( pFindCircle->Number == pCurrNode->pCircle->Number )
      Result = true;                // Если нашли, то дальше не имеет смысла искать
    else if( pCurrNode->pPrevious ) // Если есть предыдущий узел, то ищем дальше в нем
      FindMatchBack( pFindCircle, pCurrNode->pPrevious, Result );
    };
 
  const unsigned int GetMetric() const
    {
    return Metric;
    }
 
  void DrawTreeBranch( TCanvas* pCanvas, TColor Color ) // Расование текущей ветви от заданного узла до корня
    {
    Node_c* pCurrNode = this;
    do
      {
      static bool FirstFlag = true;
      int x = pCurrNode->pCircle->x,
          y = pCurrNode->pCircle->y;
      if( FirstFlag )
        {
        pCanvas->MoveTo( x, y );
        FirstFlag = false;
        }
      pCanvas->LineTo( x, y );
 
      #define ENABLESOMECOLOR 10
      int Step = Color / ( this->Metric + ENABLESOMECOLOR );
      Draw( pCurrNode->pCircle, pCanvas, Color-=Step );
 
      pCurrNode = pCurrNode->pPrevious;
      }
      while( pCurrNode );
    }
};
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
bool CheckCrossing( Circle_s* pCurrCircle, Circle_s* pCheckCircle ) // Функция проверки пересечения окружностей
{
if( pCurrCircle == pCheckCircle )
  return false;
 
if( sqrt( (pCurrCircle->x - pCheckCircle->x) * (pCurrCircle->x - pCheckCircle->x) +
          (pCurrCircle->y - pCheckCircle->y) * (pCurrCircle->y - pCheckCircle->y)  )
          <=
          pCurrCircle->Radius + pCheckCircle->Radius )
  {
  return true;
  }
 
return false;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Node_c* MakeTree( Circle_s* pCurrCircle, Node_c* pCurrNode ) // Рекурсивная функция постоения дерева
{                                                            // принимает центр окружности, какой засеять дерево, и указатель на дерево, начинающееся из этого центра (из какого узла будем выращивать дерево)
static Node_c *pRetFarthestNode( pCurrNode );  // На все рекуррентные вызовы один общий указатель
for( int count=0; count<CountCircles; count++ ) // Цикл перебор всех центров ( сравнение с принятым центром )
  {
  Circle_s *pNewCircle = &ArrCenterCircles[count]; // Для удобства берем указатель на элемент массива ( на окружность )
  if( CheckCrossing( pCurrCircle, pNewCircle ) )   // Если нашлось пересечение, то
    {
    bool AlreadyExists = false;
    pCurrNode->FindMatchBack( pNewCircle, pCurrNode, AlreadyExists ); // Проверка встречался ли элемент в текущей ветке дерева
    if( !AlreadyExists ) // Если нет этой окружности в текущей ветке, то
      {
      Node_c *pNextNode = pCurrNode->MakeNode( pNewCircle, pCurrNode->GetMetric() + 1 ); // Создали узел из окружности и вернули на него указатель и увеличили его метрику
                                                                                         // Тем самым добавили его к текущему дереву ( У текущего узла может быть несколько дочерних на одном уровне )
      if( pNextNode->GetMetric() > pRetFarthestNode->GetMetric() )
        pRetFarthestNode = pNextNode;
      //Form1->Memo1->Lines->Add( String().sprintf("CN:%d NN:%d M:%d",pCurrCircle->Number,pNewCircle->Number,pNextNode->GetMetric()) );
      MakeTree( pNewCircle, pNextNode ); // Рекурсивная функция( строим дерево дальше )
      }
    }
  }
return pRetFarthestNode;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
srand( time( NULL ) );
for( int i=0; i<CountCircles; i++ ) // Засеиваем изначальный массив окружностей
  {
  #define R ArrCenterCircles[i].Radius
  ArrCenterCircles[i].Radius = rand() % (RADIUSMAX-RADIUSMIN) + RADIUSMIN;
 
  ArrCenterCircles[i].x = rand() % (FIELD->Width  - R*2) + R;
  ArrCenterCircles[i].y = rand() % (FIELD->Height - R*2) + R;
  ArrCenterCircles[i].Number = i;
  }
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::FormCreate(TObject *Sender)
{
for( int i=0; i<CountCircles; i++ ) // Рисуем все подряд
  {
  Draw( &ArrCenterCircles[i], FIELD->Canvas, clBlack );
  }
 
 
 
std::vector< Node_c* > Trees; // Дерево будет выращено для каждой окружности
for( int i=0; i<CountCircles; i++ )
  {
  Circle_s *pCurrCircle = &ArrCenterCircles[i];     // Для удобства
  Node_c *pCurrTree = new Node_c( pCurrCircle, 0 ); // Инициализируем дерево текущей окружностью
 
  Node_c* pFarthestNodeInTree = MakeTree( &ArrCenterCircles[i], pCurrTree ); // Получаем наидальнейший узел построенного дерева
 
  Trees.push_back( pFarthestNodeInTree ); // Заполняем вектор наидальнейшими листами каждого дерева
  }
 
 
 
std::vector< Node_c* >::iterator IterTree = Trees.begin();
Node_c* pFarthestNodeInAllForest( *IterTree ); // Собственно искомый конец самой длинной цепочки окружностей
 
for( ; IterTree != Trees.end(); ++IterTree ) // Лучше конечно использовать algorithm::max_element(,,)
  {
  if( pFarthestNodeInAllForest->GetMetric() < (**IterTree).GetMetric() )
    pFarthestNodeInAllForest = *IterTree;
  }
pFarthestNodeInAllForest->DrawTreeBranch( FIELD->Canvas, clRed );
}
//---------------------------------------------------------------------------