/*------------------------------------------------------------------------------
1||Szum(Ci)  Utemezesi fedadat megoldasa SPT ütemezési szabály alkalmazásával.
Egygépes termelésiütemezési feladat.
Az ütemezés célja a befejezési idők összegének minimalizálása, 
ezáltal az átlagos készletszint minimalizálása.
SPT Shortest Processing Time (műveleti idő szerint nemcsökkenő munkasorrend)
A megoldás optimális ütemtervet eredményez. 
-------------------------------------------------------------------------------*/


#include<stdio.h>
#include<alloc.h>
#include<stdlib.h>
#include<conio.h>

typedef struct{
                int id;
                long ProcT,
                     StartT,
                     EndT;
              }T_JOB;

typedef struct{
               long Csum;
              }T_OBJF;

void Simulation(T_JOB* job, int N, int* sch, long t);
void Evaluation(T_JOB* job, int N, T_OBJF* obj);
void print_job(T_JOB* job, int N);
void SPT_rule(T_JOB* job, int N, int* sch);

int main(int argc, char* argv[])
{
 T_JOB* job;
 int* sch;
 T_OBJF obj;
 int N;
 int i;

 printf("\n Kerem a munkak szamat:");
 scanf("%d", &N);
 randomize();
 job = (T_JOB*) calloc( N, sizeof(T_JOB));
 for (i=0; i<N; i++)
 {
    job[i].id = i;
    job[i].ProcT = 1 + random(20);
 }

 sch = (int*) calloc(N, sizeof(int));
 /*Ad-hoc*/
 for (i=0; i<N; i++)
 {
  sch[i]=i;
 }

 Simulation(job, N, sch, 0);
 Evaluation(job, N, &obj);
 //print_job(job, N);
 printf("\n Ad-hoc sorrend eseten Csum=%ld", obj.Csum);

 /*SPT*/
 SPT_rule(job, N, sch);
 Simulation(job, N, sch, 0);
 Evaluation(job, N, &obj);
 printf("\n Ad-hoc sorrend eseten Csum=%ld", obj.Csum);


 getch();



 free (sch);
 free (job);
 return 0;
}
//---------------------------------------------------------------------------
void Simulation(T_JOB* job, int N, int* sch, long t)
{
 int i;

 job[ sch[0] ].StartT = t;
 job[ sch[0] ].EndT = job[ sch[0] ].StartT + job[ sch[0] ].ProcT;
 for (i=1; i<N; i++)
 {
   job[ sch[i] ].StartT = job[ sch[i-1] ].EndT;
   job[ sch[i] ].EndT = job[ sch[i] ].StartT + job[ sch[i] ].ProcT;
 }

}

void Evaluation(T_JOB* job, int N, T_OBJF* obj)
{
  int i;
  obj->Csum = 0;

  for (i=0; i<N; i++)
    obj->Csum += job[i].EndT;

}

void print_job(T_JOB* job, int N)
{
 int i;
 printf("\n id \t StartT \t ProcT \t EndT");

 for (i=0; i<N; i++)
  {
   printf("\n %d \t %ld \t %ld \t %ld",
   job[i].id,
   job[i].StartT,
   job[i].ProcT,
   job[i].EndT);
  }
}

void SPT_rule(T_JOB* job, int N, int* sch)
{
  int temp;
  int i, j;

  for (i=0; i<N-1; i++)
    for (j=i+1; j<N; j++)
      {
        if ( job[ sch[i] ].ProcT > job[ sch[j] ].ProcT )
          {
            temp = sch[i];
            sch[i] = sch[j];
            sch[j] = temp;
          }
      }

}