1800 - Matop

Enunt

Ilie a fost chemat de urgenţă în localitatea natală, la Fărcășești, pentru a rezolva o problemă care ar ajuta la reducerea poluării provocate de mina din localitate. Din păcate soluţia lui Ilie rezolvă optim doar un sfert din problemă aşa că vă cere ajutorul. Problema este următoarea:

Se dă o matrice pătratică cu N linii şi N coloane care iniţial are toate elementele egale cu 0. Pe această matrice se execută 4 tipuri de operaţii:

1 LIN VAL: toate elementele de pe linia LIN cu valoarea mai mică decât VAL iau valoarea VAL.

2 COL VAL: toate elementele de pe coloana COL cu valoarea mai mică decât VAL iau valoarea VAL.

3 LIN COL: să se afişeze valoarea elementului de pe linia LIN şi coloana COL.

4: să se afişeze suma elementelor de pe diagonala principală.

Cerinţa

Dat fiind N şi K operaţii, să se execute fiecare în ordinea citirii.

Date de intrare

Fişierul de intrare matop.in va conţine pe prima linie două numere naturale N, K reprezentând dimensiunile matricei şi numărul de operaţii care trebuie efectuate. Pe următoarele K linii se află descrierea unei operaţii în formatul precizat mai sus.

Date de ieşire

Fişierul matop.out ​va conţine pentru fiecare operaţie de tip 3 şi 4 din fişierul de intrare răspunsul opeaţiei corespunzătoare.

Restricţii şi precizări

1 ≤ N ≤ 25.000 1 ≤ K ≤ 100.000 1 ≤ LIN ≤ N 1 ≤ COL ≤ N 0 ≤ VAL ≤ 100.000 Pentru 40% din teste 1 ≤ N, K ≤ 100

Exemplu

matop.in

5 11

1 1 1

2 2 3

3 1 4

2 3 9

1 5 2

1 4 4

3 4 3

3 1 2

1 1 10

3 1 3

4

matop.out

1

9

3

10

28

Rezolvare

<syntaxhighlight lang="python" line="1">

1. 1800 matop

def execute_operations(N, K, operations):

   matrix = [[0] * N for _ in range(N)]
   diagonal_sum = 0
   output = []

   for op in operations:
       op_type, *args = op

       if op_type == 1:
           lin, val = args
           for j in range(N):
               matrix[lin - 1][j] = max(matrix[lin - 1][j], val)
       elif op_type == 2:
           col, val = args
           for i in range(N):
               matrix[i][col - 1] = max(matrix[i][col - 1], val)
       elif op_type == 3:
           lin, col = args
           output.append(matrix[lin - 1][col - 1])
       elif op_type == 4:
           diagonal_sum += sum(matrix[i][i] for i in range(N))

   if diagonal_sum:
       output.append(diagonal_sum)

   # Scrierea rezultatelor în fișierul 'matop.out'
   with open('matop.out', 'w') as file_out:
       for result in output:
           file_out.write(str(result) + '\n')

def validate_input(N, K, operations):

   if not isinstance(N, int) or not isinstance(K, int) or not (1 <= N <= 1000) or not (1 <= K <= 1000):
       return False, "Numerele N și K trebuie să fie întregi între 1 și 1000."

   if not isinstance(operations, list) or not all(isinstance(op, list) and len(op) >= 1 for op in operations):
       return False, "Lista de operații trebuie să fie o listă de liste cu cel puțin un element."

   return True, None

def main():

   try:
       # Citirea datelor de intrare din fișierul 'matop.in'
       with open('matop.in', 'r') as file:
           N, K = map(int, file.readline().split())
           operations = [list(map(int, line.split())) for line in file.readlines()]
   except (ValueError, FileNotFoundError):
       print("Date de intrare invalide sau fișierul nu există.")
       return

   is_valid, error_message = validate_input(N, K, operations)

   if not is_valid:
       print("Date de intrare invalide:", error_message)
       return

   # Executarea operațiilor și afișarea rezultatelor în fișierul 'matop.out'
   execute_operations(N, K, operations)

if __name__ == "__main__":

   main()

</syntaxhighlight>