Implementowanie pierwszego pasującego algorytmu:

Question

Problem: Mam 3 maszyny, każda maszyna ma limit 30 ms, każda maszyna ma 3 strefy, których nie można tam wykonać. Zadania mają wartość P (priorytet) i W (waga, czyli czas wykonania zadania w tej konfiguracji), zadania muszą być najpierw uporządkowane według priorytetu, od niższego do wyższego w następujący sposób:

Zadanie 01 { 6, 2} // P/W = 3 to zadanie wykonywane w ostatnim (3)

zadanie 02 {7, 7} // P/w = 1 to zadanie wykonywane pierwszy (1)

zadanie 03 { 4, 2} // P/W = 2 to zadanie zostało wykonane jako drugie (2)

Teraz, aby wykonać zadanie (mam 6), muszę sprawdzić wszystkie 3 maszyny, aby znaleźć pierwsze dopasowanie do zadania , aby wybrać dopasowanie do zadania, musi być optymalnym w 3 maszynach, przykład:

Maszyna 01; | ----- 5 ---- 9 ------- 16-17--19-20 |

Maszyna 02: | ---- 4-5--7-8 --------- 17-18-- |

Maszyna 03: | ----- 5 --- 8--10 --- 13--15 --- 18-- |

(1) Zadanie 02 wykonane w maszynie 02 (Szukamy P ms do wykonania zadania i minimalnego czasu na rozpoczęcie zadania, ponieważ zarówno maszyna 01 (począwszy od 9 ms) i 02 (począwszy od 8 ms) mieć wolny czas 7 ms, maszyna 02 może najpierw uruchomić zadanie, a następnie maszynę 01).

(2) Zadanie 03 wykonane w maszynie 02 (Szukamy P ms, aby wykonać zadanie).

(3) Zadanie 01 wykonane w komputerze 01 (Szukamy P ms do wykonania zadania).

Niektóre okresy są zdefiniowane jako krytyczne i nie można ich użyć do planowania pracy. Te okresy (na przykład 5-9, 7-8) są przechowywane w dedykowanej strukturze z_indispo.

Strukturę bfeet używa się do przechowywania zarówno przy uruchamianiu zadania, jak i na maszynie wiedźmy.

I wdrożone przeważnie całą algorytm w C, ale moje wyniki są inne niż oczekiwano:

#include <stdio.h> 

typedef struct _z_indispo { 
    int t1; 
    int t2; 
} z_indispo; 

typedef struct _machines { 
    int t[20]; // array represent time 
    z_indispo zone[2]; 
} machines; 

typedef struct _tache { 
    int p; 
    int w; 
    int c; // p/w 
    int i; // Task number 
} tache; 

typedef struct _bfeet { 
    int t; // Store the time to of ending execution by a task 
    int m; // The machine responsible for executing a task. 
} bfeet; 

int main(int argc, char **argv) 
{ 
    machines m[4]; 
    tache j[6]; 
    tache j_tmp; 
    bfeet b[4]; 
    int i = 0; 
    int n = 0; 
    int u = 0; 
    int k = 0; 
    int count = 0; 
    int trouver = 0; 
    int f_totale = 0; 
    int f[3] = {0}; 

    m[0].zone[0].t1 = 7; 
    m[0].zone[0].t2 = 9; 
    m[0].zone[1].t1 = 14; 
    m[0].zone[1].t2 = 15; 

    m[1].zone[0].t1 = 8; 
    m[1].zone[0].t2 = 9; 
    m[1].zone[1].t1 = 16; 
    m[1].zone[1].t2 = 17; 

    m[2].zone[0].t1 = 7; 
    m[2].zone[0].t2 = 8; 
    m[2].zone[1].t1 = 18; 
    m[2].zone[1].t2 = 19; 



    /* 
    * Initialise all machines 
    * 0: Represent free time. 
    * -1: Represent critical zone range. 
    * -2: Represent a task already executed. 
    */ 
    for(i = 0; i< 3; ++i) 
    { 
     for(count = 0; count < 20; ++count) 
     { 
      if((count >= m[i].zone[0].t1 - 1 && count <= m[i].zone[0].t2 - 1) || 
       (count >= m[i].zone[1].t1 - 1 && count <= m[i].zone[1].t2 - 1)) 
      { 
       m[i].t[count] = -1; 
      } 
      else 
      { 
       m[i].t[count] = 0; 
      } 
     } 
    } 

    for(i = 0; i< 3; ++i) 
    { 
     if(i == 0) 
      printf(" D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3)\n"); 
     else if(i == 1) 
      printf(" D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3)\n"); 
     else if(i == 2) 
      printf(" D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3)\n"); 
     printf("|"); 
     for(count = 0; count < 20; ++count) 
     { 
       printf("%3d", m[i].t[count]); 

     } 

     printf(" |\n\n"); 
    } 

    j[0].p = 5; 
    j[0].w = 2; 
    j[0].i = 1; 

    j[1].p = 9; 
    j[1].w = 3; 
    j[1].i = 2; 

    j[2].p = 6; 
    j[2].w = 3; 
    j[2].i = 3; 

    j[3].p = 6; 
    j[3].w = 4; 
    j[3].i = 4; 

    j[4].p = 7; 
    j[4].w = 7; 
    j[4].i = 5; 

    /* 
    * Calc C = P/W . 
    */ 
    for(count = 0; count < 5; ++count) 
    { 
     j[count].c = j[count].p/j[count].w; 
    } 

    /* 
    * Sort tasks from low to hight 
    */ 
    for(count = 0; count < 5; ++count) 
    { 
     for(k = 0; k < 5 - count; ++k) 
     { 
      if(j[k].c > j[k + 1].c) 
      { 
       j_tmp = j[k + 1]; 
       j[k + 1] = j[k]; 
       j[k] = j_tmp; 
      } 
     } 
    } 


    /*printf("|%2J |%2 P |%2 W | C |\n"); 
    printf("_____________________\n"); 
    for(count = 0; count < 5; ++count) 
    { 
     printf("|%-4d|%-4d|%-4d|%-4d|\n", j[count].i, j[count].p, j[count].w, j[count].c); 
    } 

    printf("\n");*/ 

    /* 
    * Execute tasks 
    */ 
    while(n < 5) 
    { 
     for(count = 0; count < 3; ++count) 
     { 
      i = 0; 
      trouver = 0; 
      while(i <= 20 && trouver != 1) 
      { 
       if(m[count].t[i] == 0) // We have a free time to start with it. 
       { 
        u = 0; // num of available indexs. 
        while(m[count].t[i] != -1 && m[count].t[i] != -2) 
        { 
         if(u == j[n].p) 
          break; 

         ++u; 
         ++i; 
        } 

        if(u < j[n].p) 
        { 
         while(m[count].t[i] == -1 && m[count].t[i] == -2) // bypass unfree unites 
          ++i; 
        } 
        else if(u == j[n].p) 
        { 
         b[count].t = i - u; 
         b[count].m = count; // 
         trouver = 1; // we find the Necessary unites to start a task 
        } 
       } 
       else 
        ++i; 
      } 
     } 

     if(u < j[n].p) 
      printf("There is no free time to execute task %d", j[n].i); 
     else 
     { 
      // Find the minimum time in all machines to start a task 
      b[3].t = b[0].t; 
      b[3].m = b[0].m; 
      for(count = 0; count < 3; ++count) 
      { 
       if(b[3].t > b[count + 1].t) 
       { 
        b[3].t = b[count + 1].t; 
        b[3].m = b[count + 1].m; 
       } 
      } 

      // Put -2 to indicate that index is unfree 
      u = b[3].t + j[n].p; 
      for(count = b[3].t; count < u; ++count) 
      { 
       m[b[3].m].t[count] = -2; 
      } 

      if(b[3].m == 0) 
       f[0] = (b[3].t + j[n].p); 
      else if(b[3].m == 1) 
       f[1] = (b[3].t + j[n].p); 
      else if(b[3].m == 2) 
       f[2] = (b[3].t + j[n].p); 

      printf("Task %d end at %-2d, machine %d.\n", j[n].i, b[3].t + j[n].p, b[3].m + 1); 
     } 
     ++n; 
    } 

    printf("\n"); 
    f_totale = f[0] + f[1] + f[2]; 
    printf("F of machine 01: %d.\n", f[0]); 
    printf("F of machine 02: %d.\n", f[1]); 
    printf("F of machine 03: %d.\n", f[2]); 
    printf("Total F: %d.\n", f_totale); 
    printf("\n"); 
    /*printf("\n"); 
    for(i = 0; i< 3; ++i) 
    { 
     if(i == 0) 
      printf(" D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3)\n"); 
     else if(i == 1) 
      printf(" D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3)\n"); 
     else if(i == 2) 
      printf(" D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3)\n"); 
     printf("|"); 
     for(count = 0; count < 20; ++count) 
     { 
       printf("%3d", m[i].t[count]); 

     } 

     printf(" |\n\n"); 
    }*/ 

    return 0; 
} 

UPDATE: mam już tylko dwa niedostępności stref w każdej maszynie. Ja również uaktualniony kod naprawić kilka błędów, ale wciąż uzyskać różne wyniki następnie ten przykład: mam tej niedostępności strefy:

m[0].zone[0].t1 = 7; 
m[0].zone[0].t2 = 9; 
m[0].zone[1].t1 = 14; 
m[0].zone[1].t2 = 15; 

m[1].zone[0].t1 = 8; 
m[1].zone[0].t2 = 9; 
m[1].zone[1].t1 = 16; 
m[1].zone[1].t2 = 17; 

m[2].zone[0].t1 = 7; 
m[2].zone[0].t2 = 8; 
m[2].zone[1].t1 = 18; 
m[2].zone[1].t2 = 19; 

5 zadań:

p | 6 9 5 7 6 
w | 3 3 2 7 4 
_______________ 
c | 2 3 2 1 1 

Po zamówieniu przez c:

p | 7 6 5 6 9 
w | 7 4 2 3 3 
_______________ 
c | 1 1 2 2 3 

realizacja zadań powinno być tak:

 J4        
|_______7__9_____14_15__________| ms 

Zadanie 04 powinno kończyć się na 7, P reprezentować czas niezbędny do wykonania zadania.

 J5              
|________8_9__________16_17_____| ms 

Zadanie 05 powinna kończyć się na 7.

J1  J3            
|_______7_8_______________18_19_| ms 

Zadanie 01 powinna kończyć się na poziomie 6, zadanie 03 powinno zakończyć się w 14

UPDATE 02 (Problem stałej)

Zauważyłem dziwne zachowanie w moim programie po zainicjowaniu tablicy m [i] .t [count], znalazłem t zmieniono zmienne kapelusza odpowiedzialne za przechowywanie stref niedostępności: UWAGA: Ten problem został rozwiązany.

UPDATE03: (Ten problem ustalone, ale z nowej emisji)

Mam sytuacji, gdy zadanie nie może znaleźć niezbędne jednoczy się rozpocząć, nigdy się ten komunikat: „Nie ma wolny czas aby wykonać zadanie ", powinienem otrzymać to zadanie 2, ponieważ ma 9 jednostek, a wszystkie maszyny nie mają takiego wolnego czasu. Kod odpowiedzialny za tym teście:

for(count = 0; count < 3; ++count) // search on all machines 
    { 
     i = 0; 
     trouver = 0; 
     while(i < 20 && trouver != 1) 
     { 
      if(m[count].t[i] == 0) // We have a free time to start with it. 
      { 
       u = 0; // num of available indexs. 
       while(m[count].t[i] != -1 && m[count].t[i] != -2) 
       { 
        if(u == j[n].p) 
         break; 

        ++u; 
        ++i; 
       } 

       if(u < j[n].p) 
       { 
        while(m[count].t[i] == -1 && m[count].t[i] == -2) // bypass unfree unites 
         ++i; 
       } 
       else if(u == j[n].p) 
       { 
        b[count].t = i - u; 
        b[count].m = count; // 
        trouver = 1; // we find the Necessary unites to start a task 
       } 
      } 
      else 
       ++i; 
     } 
    } 
    /* u represent the number of continuous free time, 
     j[n].p represent the necessary time to execute the current task, n is the current task 
    if(u < j[n].p) 
     printf("There is no free time to execute task %d", j[n].i); 
    else 
    { 
     // Find the minimum time in all machines to start a task 
     b[3].t = b[0].t; 
     b[3].m = b[0].m; 

UPDATE04:

Teraz widzę wykluczone zadanie, gdy nie ma wolnego czasu, aby wykonać zadanie, jednak wyjście nie jest w porządku, bo widzę zadanie zastąpić okres czasu na inne zadanie:

while(n < 5) 
{ 
    k = 0; 
    for(count = 0; count < 3; ++count) 
    { 
     i = 0; 
     u = 0; 
     trouver = 0; 
     while(i < 20 && trouver != 1) 
     { 
      if(m[count].t[i] == 0) // We have a free time to start with it. 
      { 
       //u = 0; // num of available indexs. 
       if(u == j[n].p) 
        break; 
       else 
       {  
        ++u; 
        ++i; 
       } 
      } 

     if(u != j[n].p) 
     { 
      if((m[count].t[i] == -1 || m[count].t[i] == -2))// bypass unfree unites 
      { 
       u = 0; 
       ++i; 
      } 
     } 

     if(u == j[n].p) 
     { 
      ++k; 
      b[count].t = i - u; 
      b[count].m = count; // 
      trouver = 1; // we find the Necessary unites to start a task 
     } 
    } 
} 

if(u != j[n].p) 
{ 
    printf("There is no free time to execute task %d.\n", j[n].i); 
} 
else 
{ 
    // Find the minimum time in all machines to start a task 
    b[3] = b[0]; 
    for(count = 0; count < 3; ++count) 
    { 
     if(b[count].t != 0) 
      if(b[3].t > b[count + 1].t) 
      { 
       b[3] = b[count + 1]; 
      } 
    } 

    // Put -2 to indicate that index is unfree 
    u = b[3].t + j[n].p; 
    for(count = b[3].t; count < u; ++count) 
    { 
     m[b[3].m].t[count] = -2; 
    } 

    if(b[3].m == 0) 
     f[0] = (b[3].t + j[n].p); 
    else if(b[3].m == 1) 
     f[1] = (b[3].t + j[n].p); 
    else if(b[3].m == 2) 
     f[2] = (b[3].t + j[n].p); 

    printf("Task %d end at %-2d, machine %d.\n", j[n].i, b[3].t + j[n].p, b[3].m + 1); 
} 

++n; 

}

wyjściowa:

D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3) 
| 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 -1 -1 0 0 0 0 0 | 

    D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3) 
| 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 -1 -1 0 0 0 | 

    D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3) 
| 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 0 | 

| J | P | W | C | 
_____________________ 
|1 |5 |2 |2 | 
|2 |7 |3 |2 | 
|3 |8 |3 |2 | 
|5 |17 |7 |2 | 
|4 |16 |4 |4 | 

Task 1 end at 5 , machine 1. 
Task 2 end at 7 , machine 1. 
Task 3 end at 8 , machine 1. 
There is no free time to execute task 5. 
There is no free time to execute task 4. 

F of machine 01: 8. 
F of machine 02: 0. 
F of machine 03: 0. 
Total F: 8. 


    D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3) 
| -2 -2 -2 -2 -2 -2 -2 -2 -1 0 0 0 0 -1 -1 0 0 0 0 0 | 

    D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3) 
| 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 -1 -1 0 0 0 | 

    D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3) 
| 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 0 | 

Answer 1

okazało się, że problemem było to, w jaki sposób mogę szukać minimalnego czasu startu w maszynach, aby rozpocząć zadanie:

.... 

// Find the minimum time in all machines to start a task 
b[3] = b[0]; // this cause the problem 
for(count = 0; count < 3; ++count) 
{ 
    if(b[count].t != 0) 
     if(b[3].t > b[count + 1].t) 
     { 
      b[3] = b[count + 1]; 
     } 
} 

b[3] jako początek może odnosić się do urządzenia, które nie mogą rozpocząć bieżącego zadania, więc zrobiłem małą zmianę:

// Find the minimum time in all machines to start a task 
      for(count = 0; count < 3; ++count) // search only in the machines that can execute the current task 
      { 
       if(b[count].m != -1) 
       { 
        b[3] = b[count]; 
        break; 
       } 
      } 

      for(count = 0; count < 3; ++count) // search for the first machines that can execute the current task 
      { 
       if(b[count].m != -1) 
       { 
        if((b[3].t > b[count + 1].t) && (b[count + 1].m != -1)) // make sure the next machine can start the current task 
        { 
         b[3] = b[count + 1]; 
        } 
       } 
      } 

Cały algorytm:

#include <stdio.h> 

typedef struct _z_indispo { 
    int t1; 
    int t2; 
} z_indispo; 

typedef struct _machines { 
    int t[20]; // array represent time 
    z_indispo zone[2]; 
} machines; 

typedef struct _tache { 
    int p; 
    int w; 
    int c; // p/w 
    int i; // Task number 
} tache; 

typedef struct _bfeet { 
    int t; // Store the time to of ending execution by a task 
    int m; // The machine responsible for executing a task. 
} bfeet; 

int main(int argc, char **argv) 
{ 
    machines m[4] = {0}; 
    tache j[6]; 
    tache j_tmp; 
    bfeet b[4] = {0}; 
    int i = 0; 
    int n = 0; 
    int u = 0; 
    int k = 0; 
    int count = 0; 
    int trouver = 0; 
    int f_totale = 0; 
    int f[3] = {0}; 

    m[0].zone[0].t1 = 7; 
    m[0].zone[0].t2 = 9; 
    m[0].zone[1].t1 = 14; 
    m[0].zone[1].t2 = 15; 

    m[1].zone[0].t1 = 8; 
    m[1].zone[0].t2 = 9; 
    m[1].zone[1].t1 = 16; 
    m[1].zone[1].t2 = 17; 

    m[2].zone[0].t1 = 7; 
    m[2].zone[0].t2 = 8; 
    m[2].zone[1].t1 = 18; 
    m[2].zone[1].t2 = 19; 

    /* 
    * Initialise all machines 
    * 0: Represent free time. 
    * -1: Represent critical zone range. 
    * -2: Represent a task already executed. 
    */ 
    for(i = 0; i< 3; ++i) 
    { 
     for(count = 0; count < 20; ++count) 
     { 
      if((count >= m[i].zone[0].t1 - 1 && count <= m[i].zone[0].t2 - 1) || 
       (count >= m[i].zone[1].t1 - 1 && count <= m[i].zone[1].t2 - 1)) 
      { 
       m[i].t[count] = -1; 
      } 
      else 
      { 
       m[i].t[count] = 0; 
      } 
     } 
    } 

    for(i = 0; i< 3; ++i) 
    { 
     if(i == 0) 
      printf(" D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3)\n"); 
     else if(i == 1) 
      printf(" D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3)\n"); 
     else if(i == 2) 
      printf(" D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3)\n"); 
     printf("|"); 
     for(count = 0; count < 20; ++count) 
     { 
       printf("%3d", m[i].t[count]); 

     } 

     printf(" |\n\n"); 
    } 

    j[0].p = 5; 
    j[0].w = 2; 
    j[0].i = 1; 

    j[1].p = 7; 
    j[1].w = 3; 
    j[1].i = 2; 

    j[2].p = 4; 
    j[2].w = 1; 
    j[2].i = 3; 

    j[3].p = 6; 
    j[3].w = 4; 
    j[3].i = 4; 

    j[4].p = 7; 
    j[4].w = 7; 
    j[4].i = 5; 

    /* 
    * Calc C = P/W . 
    */ 
    for(count = 0; count < 5; ++count) 
    { 
     j[count].c = j[count].p/j[count].w; 
    } 

    /* 
    * Sort tasks from low to hight 
    */ 
    for(count = 0; count < 5; ++count) 
    { 
     for(k = 0; k < 5 - count; ++k) 
     { 
      if(j[k].c > j[k + 1].c) 
      { 
       j_tmp = j[k + 1]; 
       j[k + 1] = j[k]; 
       j[k] = j_tmp; 
      } 
     } 
    } 


    printf("|%2J |%2 P |%2 W | C |\n"); 
    printf("_____________________\n"); 
    for(count = 0; count < 5; ++count) 
    { 
     printf("|%-4d|%-4d|%-4d|%-4d|\n", j[count].i, j[count].p, j[count].w, j[count].c); 
    } 

    printf("\n"); 

    /* 
    * Execute tasks 
    */ 
    while(n < 5) 
    { 
     k = 0; 
     for(count = 0; count < 3; ++count) 
     { 
      i = 0; 
      u = 0; 
      trouver = 0; 
      while(i < 20 && trouver != 1) 
      { 
       if(m[count].t[i] == 0) // we find a free unite 
       { 
        while(m[count].t[i] == 0 && u != j[n].p && i < 20) // count a continues free time, quit when u equal the necessary time to execute the current task 
        { 
         ++u; 
         ++i; 
        } 

        if(u == j[n].p) // we found a free continues time 
        { 
         b[count].t = i - u; // save the starting index 
         b[count].m = count; // save the machine responsible for executing the current task 
         ++k; 
         trouver = 1; 
        } 
        else if(u != j[n].p) // if we encounter zone unavailability or index reserved by another task 
        { 
         u = 0; // restart u counter 
         while((m[count].t[i] == -1 || m[count].t[i] == -2) && (i < 20)) // bypass reserved/unavailability index's 
          ++i; 
        } 
       } 
       else 
        ++i; // bypass reserved/unavailability index's 
      } 

      if(trouver != 1) // we mark this machine as it can't execute the current task 
      { 
       b[count].m = -1; 
      } 
     } 

     if(k == 0) 
      printf("There is no free time to execute task %d.\n", j[n].i); 
     else 
     { 
      // Find the minimum time in all machines to start a task 
      for(count = 0; count < 3; ++count) // search only in the machines that can execute the current task 
      { 
       if(b[count].m != -1) 
       { 
        b[3] = b[count]; 
        break; 
       } 
      } 

      for(count = 0; count < 3; ++count) // search only in the machines that can execute the current task 
      { 
       if(b[count].m != -1) 
       { 
        if((b[3].t > b[count + 1].t) && (b[count + 1].m != -1)) 
        { 
         b[3] = b[count + 1]; 
        } 
       } 
      } 

      // Put -2 to indicate that index as unfree 
      u = b[3].t + j[n].p; 
      for(count = b[3].t; count < u; ++count) 
      { 
       m[b[3].m].t[count] = -2; 
      } 

      if(b[3].m == 0) 
       f[0] = f[0] + (b[3].t + j[n].p) * j[n].w; 
      else if(b[3].m == 1) 
       f[1] = f[1] + (b[3].t + j[n].p) * j[n].w; 
      else if(b[3].m == 2) 
       f[2] = f[2] + (b[3].t + j[n].p) * j[n].w; 

      printf("Task %d end at %-3dms, machine %d.\n", j[n].i, b[3].t + j[n].p, b[3].m + 1); 
     } 
     ++n; 
    } 

    printf("\n"); 
    f_totale = f[0] + f[1] + f[2]; 
    printf("F of machine 01: %d.\n", f[0]); 
    printf("F of machine 02: %d.\n", f[1]); 
    printf("F of machine 03: %d.\n", f[2]); 
    printf("Total F: %d.\n", f_totale); 
    printf("\n"); 
    printf("\n"); 
    for(i = 0; i< 3; ++i) 
    { 
     if(i == 0) 
      printf(" D(1,1)   t1 s1 D(1,2)  t2 s2 D(1,3)\n"); 
     else if(i == 1) 
      printf(" D(2,1)    t1 s1 D(2,2)   t2 s2 D(2,3)\n"); 
     else if(i == 2) 
      printf(" D(3,1)   t1 s1 D(3,2)     t2 s2 D(3,3)\n"); 
     printf("|"); 
     for(count = 0; count < 20; ++count) 
     { 
       printf("%3d", m[i].t[count]); 

     } 

     printf(" |\n\n"); 
    } 

    return 0; 
} 

Answer 2

Masz trwałe błędy "krótko po jednym" w definicjach tablic. Zasadniczo, tablice C są indeksowane od zera, więc jeśli chcesz uzyskać dostęp do array[n], array musi być zdefiniowany w rozmiarze co najmniej n+1. Na przykład Twój struct Maszyna powinna być

typedef struct _machines { 
    int t[20]; 
    z_indispo zone[2]; 
} machines; 

ponieważ dostęp machine.t[20] i machine.zone[1].

Rozwiązuje to problem z drugiej aktualizacji (pamięć jest tak mocno podnoszona, że ​​indeksuje się poza końcem tablicy). Pierwszy prawdopodobnie zostanie naprawiony (a przynajmniej będziesz dużo dalej na drodze do rozwiązania) po naprawieniu inicjalizacji tablic w main() podobnie (np. Masz dostęp do b[3].t, ale ponieważ zdefiniowałeś to przez bfeet b[3] ma tylko wskaźniki b[0], b[1] i b[2]).