Se dau 𝑁 procese care trebuie rulate pe un calculator. Există 𝑀 variabile care pot fi accesate de către aceste procese, numerotate de la 1 la 𝑀. Fiecare proces 𝑖 (unde 1 ≤ 𝑖 ≤ 𝑁) accesează un interval continuu de variabile [𝑙[𝑖], 𝑟[𝑖]], iar timpul necesar de execuție al procesului 𝑖 este 𝑡[𝑖].

Cât timp un proces rulează, acesta își salvează pe stiva de execuție toate variabilele necesare, iar la finalizarea lui le elimină de pe stivă. Două procese pot rula în paralel dacă și numai dacă nu au nicio variabilă în comun.

Sistemul de operare va planifica procesele astfel încât timpul total necesar executării tuturor să fie minim. O astfel
de planificare, care atinge timpul minim posibil, poartă numele de scenariu optim de execuție.

O variabilă este considerată critică dacă există cel puțin un scenariu optim de execuție în care aceasta petrece cel mai mult timp pe stivă dintre toate variabilele (într-un scenariu pot exista mai multe variabile critice simultan).

Cerința

Dat fiind un număr 𝐶 ∈ {1, 2, 3}, reprezentând tipul cerinței:

Cerința 1. Să se determine timpul minim necesar pentru a rula toate cele 𝑁 procese date.

Cerința 2. Pentru fiecare proces 𝑖 (de la 1 la 𝑁), presupunem că îl eliminăm din sistem. Fie 𝑇[𝑖] timpul minim necesar pentru a rula restul de 𝑁 − 1 procese. Să se calculeze și să se afișeze suma tuturor valorilor 𝑇[𝑖], pentru 𝑖 de la 1 la 𝑁.

Cerința 3. Pentru fiecare proces 𝑖 (de la 1 la 𝑁), presupunem că îl eliminăm din sistem. Fie 𝑉[𝑖] numărul de variabile critice în contextul celorlalte 𝑁 − 1 procese, conform definiției anterioare. Să se calculeze și să se afișeze suma tuturor valorilor 𝑉[𝑖], pentru 𝑖 de la 1 la 𝑁.

Generarea datelor

Pentru a evita citirea unui volum foarte mare de date, doar primele 𝐾 procese vor fi citite din fișierul de intrare sub forma unor triplete (𝑙[𝑖] , len[𝑖] , 𝑡[𝑖]), pentru 𝑖 de la 1 la 𝐾. Pentru cerința 𝐶 = 1, se garantează că 𝑁 = 𝐾, deci nu este necesară nicio generare suplimentară.

Pentru cerințele 𝐶 ∈ {2, 3}, se citesc doar primele 𝐾 procese. Restul proceselor, de la 𝐾 + 1 până la 𝑁, se vor genera în programul vostru folosind următorul algoritm:

1: pentru 𝑖 ← 𝐾 + 1, 𝑁 execută
2:    𝑙[𝑖] ← ((𝑙[𝑖−1] xor (𝑎 · 𝑙[𝑖−𝐾] )) mod 𝑀) + 1
3:    len[𝑖] ← ((len[𝑖−1] xor (𝑏 · len[𝑖−𝐾] )) mod 𝑀) + 1
4:    𝑡[𝑖] ← ((𝑡[𝑖−1] xor (𝑐 · 𝑡[𝑖−𝐾] )) mod 𝑇 ) + 1
5: sfârșit pentru

Notă: Operația logică pe biți XOR/„SAU exclusiv” este reprezentată în C/C++ prin operatorul ^.

Pentru toate procesele (indiferent dacă au fost citite sau generate), capătul drept al intervalului accesat de procesul 𝑖 se va calcula după formula: 𝑟[𝑖] = 𝑙[𝑖] + (len[𝑖] mod (𝑀 − 𝑙[𝑖] + 1))

Date de intrare

Fișierul de intrare calculator1.in conține pe prima linie numerele 𝐶, 𝑁 , 𝑀, 𝐾, 𝑇, urmate de constantele 𝑎, 𝑏 și 𝑐, separate prin câte un singur spațiu. Pe următoarele 𝐾 linii se vor afla câte trei numere: 𝑙[𝑖] , len[𝑖] și 𝑡[𝑖] , care reprezintă informațiile pentru primele 𝐾 procese (unde 1 ≤ 𝑖 ≤ 𝐾).

Date de ieșire

Fișierul de ieșire calculator1.out va conține pe prima linie un singur număr natural, reprezentând răspunsul calculat conform cerinței 𝐶.

Restricții și precizări

• 1 ≤ 𝑁 , 𝑀 ≤ 5 000 000
• 1 ≤ 𝐾 ≤ min(𝑁 , 100 000)
• 1 ≤ 𝑇 ≤ 10 000
• 1 ≤ 𝑙[𝑖] , len[𝑖] ≤ 𝑀 și 1 ≤ 𝑡[𝑖] ≤ 𝑇, pentru orice 1 ≤ 𝑖 ≤ 𝐾
• 1 ≤ 𝑎, 𝑏, 𝑐 ≤ 1 000 000 000
• Atenție: Calculele intermediare din algoritmul de generare a datelor pot depăși capacitatea de reprezentare a tipurilor întregi pe 32 de biți (de exemplu int sau unsigned int). Se recomandă și utilizarea tipurilor de date pe 64 de biți (de exemplu long long) unde este cazul.

Subtaskuri

• 𝐶 = 1, 1 ≤ 𝑁 , 𝑀 ≤ 2 000, 𝐾 = 𝑁
• 𝐶 = 1, 1 ≤ 𝑁 , 𝑀 ≤ 100 000, 𝐾 = 𝑁
• 𝐶 = 2, 1 ≤ 𝑁 , 𝑀 ≤ 200, 𝐾 = 𝑁
• 𝐶 = 2, 1 ≤ 𝑁 , 𝑀 ≤ 2 000, 𝐾 = 𝑁
• 𝐶 = 2, 1 ≤ 𝑁 , 𝑀 ≤ 100 000, 𝐾 = 𝑁
• 𝐶 = 2, 1 ≤ 𝑁 , 𝑀 ≤ 2 000 000
• 𝐶 = 2
• 𝐶 = 3, 1 ≤ 𝑁 , 𝑀 ≤ 200, 𝐾 = 𝑁
• 𝐶 = 3, 1 ≤ 𝑁 , 𝑀 ≤ 2 000, 𝐾 = 𝑁
• 𝐶 = 3, 1 ≤ 𝑁 , 𝑀 ≤ 100 000, 𝐾 = 𝑁
• 𝐶 = 3, 1 ≤ 𝑁 , 𝑀 ≤ 2 000 000
• 𝐶 = 3

Exemplul 1

calculator1.in

1 3 5 3 10 1 1 1
1 3 5
3 3 4
4 2 2

calculator1.out

9

Exemplul 2

calculator1.in

2 3 5 3 10 1 1 1
1 3 5
3 3 4
4 2 2

calculator1.out

20

Exemplul 3

calculator1.in

3 3 5 3 10 1 1 1
1 3 5
3 3 4
4 2 2

calculator1.out

Explicație

Pentru exemplele de mai sus, avem 𝑁 = 3 procese și 𝑀 = 5 variabile. Procesele sunt:

• Procesul 1: 𝑙[1] = 1, 𝑟[1] = 1 + (3 mod 5) = 4, timp 𝑡[1] = 5. Intervalul este [1, 4].
  • Procesul 2: 𝑙[2] = 3, 𝑟[2] = 3 + (3 mod 3) = 3, timp 𝑡[2] = 4. Intervalul este [3, 3].
  • Procesul 3: 𝑙[3] = 4, 𝑟[3] = 4 + (2 mod 2) = 4, timp 𝑡[3] = 2. Intervalul este [4, 4].

Analizând interacțiunea dintre procese se observă că:

• Procesul 1 are variabile comune atât cu Procesul 2 (variabila 3), cât și cu Procesul 3 (variabila 4). Prin urmare, 𝑃[1] nu poate rula în paralel cu 𝑃[2] sau 𝑃[3].
• Procesul 2 și Procesul 3 nu au nicio variabilă în comun, deci pot rula simultan.

Pentru primul exemplu (𝐶 = 1): Într-un scenariu optim, 𝑃[1] rulează singur (5 unități de timp), iar 𝑃[2] și 𝑃[3] rulează în paralel. Timpul necesar pentru grupul {𝑃[2], 𝑃[3]} este max(𝑡[2], 𝑡[3]) = 4. Timpul total minim este 5 + 4 = 9.

Pentru al doilea exemplu (𝐶 = 2):

• Eliminăm P[1] : Rămân 𝑃[2] și 𝑃[3], care rulează în paralel. 𝑇[1] = max(4, 2) = 4.
• Eliminăm 𝑃[2] : Rămân 𝑃[1] și 𝑃[3]. Deoarece au variabila 4 în comun, trebuie să ruleze secvențial. 𝑇[2] = 5 + 2 = 7.
• Eliminăm 𝑃[3] : Rămân 𝑃[1] și 𝑃[2]. Au variabila 3 în comun, deci rulează secvențial. 𝑇[3] = 5 + 4 = 9.

Suma rezultatelor este 4 + 7 + 9 = 20.

Pentru al treilea exemplu (𝐶 = 3):

• Fără 𝑃[1]: Timpul optim este 4. Variabila 3 stă pe stivă timp de 4 unități (cât rulează 𝑃[2]), iar variabila 4 stă pe stivă 2 unități (cât rulează 𝑃[3]). Singura variabilă critică este variabila 3. 𝑉[1] = 1.
• Fără 𝑃[2]: Timpul optim este 7. Procesele 𝑃[1] și 𝑃[3] rulează pe rând. Variabila 4 stă pe stivă în total 5 + 2 = 7 unități, fiind singura care atinge acest timp maxim. 𝑉[2] = 1.
• Fără 𝑃[3]: Timpul optim este 9. Procesele 𝑃[1] și 𝑃[2] rulează pe rând. Variabila 3 stă pe stivă în total 5 + 4 = 9 unităi, fiind singura variabilă critică. 𝑉[3] = 1.

Suma valorilor 𝑉[𝑖] este 1 + 1 + 1 = 3.