{
      k = 1;
      while ( k>0 )
         if ( существует еще неиспользованный элемент yпринадлежащий Ak, такой что
             P(X[1],X[2],...,X[k-1],y)
         {
             X[k] = y; //Элемент y использован.
              if  ((X[1],X[2],...,X[k]) является целочисленным решением)
              {
                  cout << (X[1],X[2],...,X[k]);
                   k++;
               }
         }
         else
            //Возврат на более короткое частичное решение; все эле- 
            //менты множества Ak вновь становятся неиспользованными.
            k -= 1;
   }

   AP (k);
   //Генерирование всех решений, являющихся расширением 
   //последовательности X[1],X[2],...,X[k-1].
   //Массив X - глобальный.
   {
      for (y, принадлежащего Ak, такого, что P(X[1],X[2],...,X[k-1]))
      {
         X[k] = y;
         if (X[1],X[2],...,X[k] есть целочисленное решение)
         {
             cout << X[1],X[2],...,X[k];
             AP(k+1);
          }
   }

#include <iostream.h>
#define TRUE 1
#define FALSE 0
#define Node 20 //Максимальное количество вершин в графе.
typedef int Boolean;
typedef struct L *Lref; // Тип: указатель на заголовочный узел.
typedef struct T *Tref; // Тип: указатель на дуговой узел.

//Описание типа заголовочного узла.
typedef struct L 
{ 
  int Key; //Имя заголовочного узла.
  int Count; //Количество предшественников.
  Boolean Flag; //Флаг посещения узла при обходе.
  Tref Trail; //Указатель на список смежности.
  Lref Next; //Указатель на следующий узел в списке заголовочных узлов.
};

//Описание типа дугового узла.
typedef struct T 
{ 
  Lref Id; 
  Tref Next; 
};

class Spisok
{
  private:
    Lref Head; //Указатель на голову списка заголовочных узлов.
    Lref Tail; //Указатель на фиктивный элемент 
               // в конце списка заголовочных узлов.
    int  X[Node+1];
    void SearchGraph (int, Lref *);
  public:
    Spisok() {//Инициализация списка заголовочных узлов.
              Head = Tail =  new (L); }
    Lref GetHead() { return Head; }
    Lref GetTail() { return Tail; }
    void MakeGraph ();
    void PrintGraph ();
    void Summa (int, int, int);
    void X1 (Lref t) {X[1] = t->Key;};
};

void main ()
{
  Spisok A;
  Lref t; //Рабочий указатель для перемещения 
          // по списку заголовочных звеньев.
  Lref t1;  
  int n=0,B;
  //Построение графа и вывод его структуры Вирта.
  A.MakeGraph ();
  A.PrintGraph (); cout<<endl;
  //Подсчет n - количества вершин в графе Head.
  t = A.GetHead();
  while (t!=A.GetTail())
    { n++; t = (*t).Next; }
  // ------------------------------------ 
  //Обнаружение множества индексов.
  cout << "Введите число B: "; cin >> B;
  t = A.GetHead();
  while (t!=A.GetTail())
  {
    //Инициализация.
    t1 = A.GetHead();
    while (t1!=A.GetTail())
    { t1->Flag = TRUE; t1 = t1->Next; }
      A.X1(t); t->Flag = FALSE;
      A.Summa (2,B,n);
      t = t->Next;
  }
} 

void Spisok::SearchGraph (int w, Lref *h)
//Функция возвращает указатель на заголовочный узел 
//с ключом w в графе, заданном структурой Вирта с указателем Head. 
{
  *h = Head; (*Tail).Key = w;
  while ((**h).Key!=w) *h = (**h).Next;
  if (*h==Tail)
  //В списке заголовочных узлов нет узла с ключом w.
  //Поместим его в конец списка Head.
  { Tail = new (L); (**h).Count = 0; 
    (**h).Trail = NULL; (**h).Next = Tail; }
}

void Spisok::MakeGraph ()
//Функция возвращает указатель Head на структуру 
//Вирта, соответствующую ориентированному графу.
{
  int x,y;
  Lref p,q; //Рабочие указатели.
  Tref t,r; //Рабочие указатели.
  Boolean Res; //Флаг наличия дуги.
  cout<<"Вводите начальную вершину дуги: ";
  cin>>x;
  while (x!=0)
  {
     cout<<"Вводите конечную вершину дуги: "; cin>>y;
     //Определим, существует ли в графе дуга (x,y)?
     SearchGraph (x, &p); SearchGraph (y,&q);
     r = (*p).Trail; Res = FALSE; 
     while ((r!=NULL)&&(!Res)) 
       if ((*r).Id==q) Res = TRUE; 
       else r = (*r).Next; 
     if (!Res) //Если дуга отсутствует, то поместим её в граф.
      { t = new (T); (*t).Id = q; 
        (*t).Next = (*p).Trail; (*p).Trail = t; (*q).Count++; } 
     cout<<"Вводите начальную вершину дуги: "; cin>>x;
  }
}

void Spisok::PrintGraph ()
//Вывод структуры Вирта, заданной указателем 
//Head и соответствующей ориентированному графу.
{
  Lref p; //Рабочий указатель.
  Tref q; //Рабочий указатель.

  p = Head;
  while (p!=Tail)
  {
     cout<< (*p).Key << "("; q = (*p).Trail; 
     while (q!=NULL) 
      { cout<<(*(*q).Id).Key; q = (*q).Next; } 
     cout<<")"; p = (*p).Next; cout<<" ";
  }
}

void Spisok::Summa (int k, int B, int n)
//Нахождение множества вершин в графе, заданном
//структурой Вирта с указателем Head.
{
  int i;  //Параметр цикла.
  Lref t; //Указатель на k-ю вершину частичного решения.
  Tref r;
  int S;
  int Set1[256]; //Вспомогательное множество.
  int m; //Количество элементов в Set1.

  SearchGraph (X[k-1], &t);
  r = t->Trail;
  while ( r != NULL )
  {
    X[k] = r->Id->Key;
    //Построение вспомогательного множества Set1 для
    //проверки, все ли элементы массива X различны.
    for (int j=0;j<256;Set1[j++]=0);
    for (i=1;i<=k;i++) Set1[X[i]]=1;
    //Подсчет m - количества элементов в множестве Set1.
    m = 0;
    for(i=1;i<=Node;i++)
     if (Set1[i]==1) m++;
    // ------------------------------- 
    S = 0;
    for (i=1;i<=k;i++)  S += X[i];
    // ---------------------------- 
    if  (k<n+1 && S==B && m==k)
    {
      //Вывод множества индексов на экран дисплея.
      for (i=1;i<=k;i++) cout << X[i] << " ";
      cout << endl;
    }
    else  
      if  (r->Id->Flag)
      {
         X[k] = r->Id->Key;
         r->Id->Flag = FALSE;
         Summa (k+1,B,n);
         r->Id->Flag = TRUE;
      }
    r = r->Next;
  }
}