В правильном ли направлении я иду? (Разработать программу для составления списка заданий для параллельных процессоров)

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
 
#define NUMBER_PROBLEMS 30
#define NUMBER_PROCESSORS 3
 
#define min(a,b) (a)<(b)?(a):(b)
#define max(a,b) (a)>(b)?(a):(b)
 
typedef struct {
  int s;  //Свободно
  int z;  //Занято
} processor;
 
processor pr[NUMBER_PROCESSORS];
int formS[NUMBER_PROBLEMS];  //Формируемый вектор разбиений
int bestS[NUMBER_PROBLEMS];  //Лучший вектор
int bestTime = -1;           //Лучшее время
int allTime  = -1;  //Общее время выполнения всех задач на 1 процессоре
int svobTime = -1;  //Свободное время на процессор
int vloj = -1;  //Вложенность рекурсии
int Z[NUMBER_PROBLEMS] = {8, 4, 3, 2, 1, 5, 8, 9, 4, 4, 2, 7, 6, 1, 15, 10, 53, 2, 1, 10, 3, 2, 5, 3, 16, 13, 6, 7, 15, 15}; //Время выполнения заданий
int flag = -1;  //Найдено решение или нет
 
//Функции
void qSort(int *, int, int);    //Быстрая сортировка(по убыванию)
int summ(int *, int);           //Суммирование элементов массива
int work();                     //
int maxVect(int *, int);        //Возвращает максимальный элемент массива
void start();                   //распределяет время выполнения задач по процессорам
 
int main()
{
  setlocale(LC_ALL, "");
  for(int i=0; i<NUMBER_PROBLEMS; i++)
    formS[i]=bestS[i] = -1;
 
  allTime = summ(Z, NUMBER_PROBLEMS);
  svobTime = allTime / 3;
  (allTime % 3 > 0) ? (svobTime++):(svobTime);
  if(maxVect(Z, NUMBER_PROBLEMS) > svobTime) svobTime = maxVect(Z, NUMBER_PROBLEMS);
  qSort(Z, 0, NUMBER_PROBLEMS-1);
  //Вывод отсортированного массива
  for(int i=0; i<NUMBER_PROBLEMS; i++)
    printf("%4d", Z[i]);
  printf("<<<\n");
 
  //Пока не будет найдено решение
  while(work())
    svobTime += 1;
 
  //Выводим лучшее время
  printf("Best Time = %d\n", bestTime);
 
  fflush(stdin);
  getchar();
  return 0;
}
//Определения------------------------------------------------
//Общая
int work()
{
  flag = -1;
 
  razb(0, 0);
  if(flag == 1) return 0;
  return 1;
}
 
//Сумма элементов вектора
int summ(int *array, int size)
{
  int res = 0;
  for(int i=0; i<size; i++)
    res += array[i];
  return res;
}
 
//Макс вектора
int maxVect(int *array, int size)
{
  int max = array[0];
  for(int i=1; i<size; i++)
    if(max < array[i]) max = array[i];
  return max;
}
//Быстрая сортировка
void qSort(int *array, int left, int right)
{
  int x = array[(left+right) / 2],
      size = right;
  do {
    while(array[left] > x) left++;
    while(array[right] < x) right--;
 
    if(left <= right) {
      int tmp = array[left];
      array[left] = array[right];
      array[right] = tmp;
      left++; right--;
    }
  } while(left <= right);
 
  if(right > 0) qSort(array, 0, right);
  if(left < size) qSort(array, left, size);
}
 
//Проверка
int check(int number)
{
  for(int i=0; i<number; i++)
    if(pr[i].s < 0) return 1;
  return 0;
}
 
//Добавление задач в процессор
void start()
{
  for(int i=0; i<NUMBER_PROCESSORS; i++) {
    pr[i].s = svobTime;
    pr[i].z = 0;
  }
 
  int i = 0;
  while(i <= vloj)
  {
    if(formS[i]>-1 && formS[i] < 4){
        pr[formS[i]-1].s -=Z[i];
        pr[formS[i]-1].z +=Z[i];
    }
    i++;
  }
}
 
//Все разбиения
void razb(int i, int p)
{
  vloj = i;
  int b = (NUMBER_PROBLEMS-i+1 > NUMBER_PROCESSORS-p+1) ? 1 : p+1;
 
  int minn = min(p+1, NUMBER_PROCESSORS);
  for(int x=b; x<=minn; x++)
  {
    if(flag == 1) continue;
    formS[i] = x;
    for(int j=i+1;j<NUMBER_PROBLEMS;j++)
        formS[j]=-1;
 
    start();                          //
    if(check(NUMBER_PROCESSORS)){     //
      continue;                       //
    }                                 //
 
    if(i == NUMBER_PROBLEMS-1)
    {
      for(int i=0; i<NUMBER_PROBLEMS; i++)
        printf("%4d", formS[i]);
      printf("\n");
      start();
      if(max(pr[0].z, max(pr[1].z, pr[2].z)) < bestTime) bestTime = max(pr[0].z, max(pr[1].z, pr[2].z));
      for(int i=0; i<NUMBER_PROBLEMS; i++) {
        bestS[i] = formS[i];
        formS[i] = -1;
      }
      flag = 1;
    }
    else
    {
      razb(i+1, max(x, p));
    }
  }
}