Editing 4128 - Iluminat

Primarul orașului X dorește să aibă un iluminat public modern. Pentru aceasta, realizează o schiță sub forma unui pătrat cu <code>n</code> linii și <code>n</code> coloane în care fiecare element situat la intersecția unei linii cu o coloană reprezintă un cartier.

Primarul a calculat pentru fiecare cartier care este numărul de stâlpi de iluminat public din acel cartier. Fiecare stâlp are un singur bec care inițial este aprins. Acesta a observat un lucru interesant: toate cartierele au un număr diferit de stâlpi de iluminare, iar valoarea maximă a numărului de stâlpi dintr-un cartier este <code>n<sup>2</sup></code>.

Pentru a fi realizată într-un mod cât mai eficient, stingerea becurilor se realizează în următorul mod:

* în prima etapă se sting becurile din cartierul cu număr maxim de stâlpi de iluminat, ceea ce duce la stingerea becurilor din cartierele de pe aceeași linie precum și din cele pe aceeași coloană cu cartierul cu număr maxim de stâlpi.
* procedeul se reia la fiecare etapă pentru toate cartierele în care nu au fost stinse becurile, până când rămâne un singur cartier iluminat.

= Cerința =
Cunoscând numerele naturale nenule <code>n</code> și <code>k</code>, precum și numărul de stâlpi de iluminat din fiecare cartier, să se determine:

* Câți stâlpi de iluminat se află în cartierul cu număr maxim de stâlpi de iluminat la etapa cu numărul <code>k</code> din procedeul de stingere a becurilor?
* Câte becuri se sting, în total, la etapa cu numărul <code>k</code>?
* Care este numărul maxim de becuri aprinse într-o zonă pătratică a orașului de dimensiune <code>k x k</code>, înainte de a începe stingerea becurilor?

= Date de intrare =
Fișierul de intrare <code>iluminat.in</code> conține pe prima linie o cifră <code>c</code> (<code>1</code>, <code>2</code> sau <code>3</code>), reprezentând cerința cerută. Pe linia următoare se găsesc două numere naturale nenule <code>n</code> și <code>k</code>, separate printr-un spațiu. Pe următoarele <code>n</code> linii se află <code>n<sup>2</sup></code> numere naturale distincte, câte <code>n</code> pe fiecare linie, separate prin câte un spațiu, cu semnificația din enunț.

= Date de ieșire =
În fișierul de ieșire <code>iluminat.out</code> se va afișa răspunsul în funcție de cerință:

* dacă <code>c = 1</code> se va afișa pe prima linie un singur număr reprezentând numărul de stâlpi de iluminat din cartierul cu număr maxim de stâlpi de iluminat la etapa <code>k</code>
* dacă <code>c = 2</code> se va afișa pe prima linie un singur număr reprezentând câte becuri se sting, în total, la etapa cu numărul <code>k</code>
* dacă <code>c = 3</code> se va afișa numărul maxim de becuri aprinse într-o zonă pătratică de dimensiune <code>k x k</code> înainte de stingerea becurilor

= Restricții și precizări =

* <code>c ∈ {1, 2, 3}</code>
* <code>1 ≤ k < n ≤ 1000</code>
* Numărul de becuri din fiecare cartier este mai mic sau egal cu <code>n<sup>2</sup></code>

= Exemplu: =
<code>iluminat.in</code>
 1
 4 2
 1 2 3 4
 16 13 5 6
 12 9 7 14
 10 11 8 15
<code>iluminat.out</code>
 15

=== Explicație ===
Cerința este <code>1</code>. Se sting becurile din cartierul având <code>16</code> stâlpi de iluminat, ceea ce duce la stingerea becurilor de pe stâlpii din linia <code>2</code> și din coloana <code>1</code>. Tabloul devine:

<code>0  2  3  4</code>

<code>0  0  0  0</code>

<code>0  9  7 14</code>

<code>0 11  8 15</code>

La etapa a doua, primul cartier în care se sting becurile are <code>15</code> stâlpi de iluminat.

<syntaxhighlight lang="python" line="1">
import numpy as np

def generate_matrix(n):
    return np.arange(1, n*n + 1).reshape(n, n)

def find_max_and_sting(matrix):
    max_value = np.max(matrix)
    max_index = np.unravel_index(np.argmax(matrix, axis=None), matrix.shape)
    row, col = max_index
    matrix[row, :] = 0
    matrix[:, col] = 0
    return max_value, np.count_nonzero(matrix == 0)

def max_bulbs_in_kxk(matrix, k):
    max_sum = 0
    for i in range(matrix.shape[0] - k + 1):
        for j in range(matrix.shape[1] - k + 1):
            submatrix_sum = np.sum(matrix[i:i+k, j:j+k])
            if submatrix_sum > max_sum:
                max_sum = submatrix_sum
    return max_sum

def stage_results(n, k):
    matrix = generate_matrix(n)
    original_matrix = matrix.copy()
    
    max_value_at_k = 0
    total_sting_at_k = 0
    
    for stage in range(1, k + 1):
        max_value, sting_count = find_max_and_sting(matrix)
        if stage == k:
            max_value_at_k = max_value
            total_sting_at_k = sting_count

    max_in_kxk_before_sting = max_bulbs_in_kxk(original_matrix, k)
    
    return max_value_at_k, total_sting_at_k, max_in_kxk_before_sting

# Citirea datelor de intrare
n = int(input())
k = int(input())

# Calcularea și afișarea rezultatelor
max_value_at_k, total_sting_at_k, max_in_kxk_before_sting = stage_results(n, k)

print(max_value_at_k)
print(total_sting_at_k)
print(max_in_kxk_before_sting)
</syntaxhighlight>