Покрытие множеств

#include <stdio.h>
#include <string.h>
#include <alloc.h>
 
typedef unsigned long LU;
typedef struct {
    LU *ss;    /* Массив LU */
    int ms;       /* Выделено памяти на ss */
    int ns;       /* Заполнено */
    int st;       /* Шаг приращения памяти для ss */
               }  XXL;
XXL *newXXL();        /* Генерация  */
addXXL (XXL *x, LU A);    /* Новый элемент */
cutXXL0(XXL *x, int k);  /* Удаление элемента k */
 
static double a[7]={ 1, 3, 2, 2, 1, 2, 3 }; //vesa
static LU  A[7] = { 0xA2, 0x14A, 0x33, 0x124, 0x51, 0xD, 0xB5 };
static LU U;
static int N = 7;  // kol-vo podmnogestv
static int n = 9;  // kol-vo elementov polnogo mnogestva
static XXL *xx;
 
XXL *newXXL()           /* Генерация  */
{ XXL *x;
    x = (XXL *)malloc(sizeof(XXL));
    x->ss = NULL;
    x->ms = x->ns = 0;
    x->st = 20;
    return(x);
}
/*********/
locXXL (XXL *x)    /* Перераспределение памяти для добавки строки (если нужно) */
{
   if (x->ss==NULL) {
       x->ms = x->st;
       x->ss = (LU *)malloc( x->ms * sizeof(LU));
   }
   if (x->ns>=x->ms) {
       x->ms += x->st;
       x->ss = (LU *)realloc(x->ss,x->ms*sizeof(LU));
   }
}
/*********/
addXXL (XXL *x, LU A)    /* Новый элемент */
{
   locXXL(x);
   x->ns++;
   x->ss [x->ns - 1] = A;
}
/********/
cutXXL0(XXL *x, int k)  /* Удаление k-того элемента */
{  int j; LU *ss=x->ss;
 
  if (k<0) return;
  if (x==NULL || k<0 || k>=x->ns || n==0) return;
  for(j=k; j<x->ns-1; j++) ss[j] = ss[j+1];
  x->ns --;
}
/*******************/
void main()
{ int i, j; LU Q; double s;
  xx = newXXL();
  U = 0; // Togda polnoe mnojestvo delaetsya tak:
  for(i=0; i<n;i++ )   U |= (1L<<i);
//  printf ("U = %lx\n", U); // DEB
  Pokr(0, 0L, 0L);
  for(i=0; i<xx->ns; i++) {
    Q = xx->ss[i];
    s = 0;
    for (j=0; j<N; j++) { // Pechat' naydennogo pokrytiya i ego ceny
      if ( (Q & (1L<<j))!=0 ) {
        printf("%c ", 'A'+j);
        s += a[j];
      }
    }
    printf("s=%f\n", s);
  }
}
/*****************/
// Y - pokrito  P - who ispol'zovan J - s kakovo nachinat'
Pokr(int J, LU Y, LU P)
{ LU Q, Z; int i, ii;
 
   for(i=J; i<N; i++) {
     if (((Y^A[i]) & (Y^U))==0) continue; // A[i] nichego ne dobavit
     Z = (Y|A[i]);
     Q = (P|(1L<<i));
     if (Z==U) {
        for(ii=0; ii<xx->ns; ii++) {  // не всходит ли данное покрытие в предывгщие и наоборот
          if (((Q^xx->ss[ii]) & (Q^U))==0) break; // ii-тое из ранее полученных < Q
          if (((Q^xx->ss[ii]) & (xx->ss[ii]^U))==0) {  //
            cutXXL0(xx, ii);
            ii--;
            continue;
          }
        }
        if (ii == xx->ns) addXXL(xx, Q);
        continue;
     }
     Pokr(i+1, Z, Q); // Recursia!
   }
}
/*****************/