Editing 0838 - Iesire

==Cerința==
Se dă planul unei clădiri pătrate formate din n*n camere, sub forma unei matrice cu n linii și n coloane și elemente 0 sau 1. Camerele marcate cu 0 sunt libere, cel marcate cu 1 sunt inaccesibile și fiecare cameră are o pereche de coordonate, de forma I J, reprezentând linia și coloană pe care este situată camera. Dintr-o cameră liberă se poate trece în altă cameră liberă, cu condiția să se învecineze pe linie sau pe coloană.

Administratorul clădirii primește o listă cu coordonatele a m camere pentru care s-au găsit potențiali chiriași. Nu pot fi închiriate decât camerele libere și accesibile din exteriorul clădirii – adică să existe o succesiune de camere învecinate care începe pe o latură a clădirii și se încheie la camera respectivă.

Pentru fiecare dintre camerele din listă, verificați dacă poate fi închiriată sau nu.
==Date de intrare==
Fișierul de intrare iesire.in conține pe prima linie numerele n m. Următoarele n linii conțin câte n elemente, 0 sau 1, cu semnificația din enunț. Următoarele m linii conțin câte două numere X Y, reprezentând coordonatele unei camere din listă.

==Date de ieșire==
Fișierul de ieșire iesire.out va conține m linii; fiecare dintre ele va conține mesajul da, dacă camera corespunzătoare din listă poate fi închiriată, respectiv nu în caz contrar.

==Restricții și precizări==

*1 ≤ n ≤ 100
*1 ≤ m ≤ 10
*1 ≤ x,y ≤ n

==Exemplu==
===Exemplu1===
:Intrare:
;alpinisti.in
;6 3
;1 1 1 1 1 0
;1 0 0 0 1 1
;1 0 1 1 0 0
;0 1 0 1 0 1
;1 0 0 1 0 1
;1 1 0 1 1 0
;4 3
;2 2
;5 5

:Iesire:
;alpinisti.out
;da
;nu
;da



==Rezolvare==
<syntaxhighlight lang="python" line="1">
 
def validare_date_intrare(n: int, m: int, matrice: list, camere: list) -> bool:
    if not (1 <= n <= 100 and 1 <= m <= 10):
        return False
    if not all(len(row) == n for row in matrice):
        return False
    if not all(1 <= x <= n and 1 <= y <= n for x, y in camere):
        return False
    return True


def poate_fi_inchiriata(n: int, matrice: list, x: int, y: int) -> bool:
    def dfs(i: int, j: int, viz: list) -> bool:
        if i < 0 or i >= n or j < 0 or j >= n:
            return False
        if viz[i][j]:
            return False
        if matrice[i][j] == 1:
            return False
        if i == 0 or i == n-1 or j == 0 or j == n-1:
            return True
        viz[i][j] = True
        if dfs(i+1, j, viz) or dfs(i-1, j, viz) or dfs(i, j+1, viz) or dfs(i, j-1, viz):
            return True
        return False

    return dfs(x-1, y-1, [[False]*n for _ in range(n)])


def main():
    with open("iesire.in") as fin:
        n, m = map(int, fin.readline().split())
        matrice = [list(map(int, fin.readline().split())) for _ in range(n)]
        camere = [tuple(map(int, fin.readline().split())) for _ in range(m)]

    if not validare_date_intrare(n, m, matrice, camere):
        print("Date de intrare invalide!")
        return

    with open("iesire.out", "w") as fout:
        for x, y in camere:
            if poate_fi_inchiriata(n, matrice, x, y):
                fout.write("da\n")
            else:
                fout.write("nu\n")
if __name__ == '__main__':
    main()


</syntaxhighlight>

==Explicații ==
Codul are 3 funcții și o funcție main() care coordonează tot procesul de citire, validare a datelor de intrare, rezolvare a problemei și scrierea rezultatelor în fișierul de ieșire.

#1 Prima funcție, validare_date_intrare(n: int, m: int, matrice: list, camere: list) -> bool, primește ca parametri dimensiunile matricei, matricea în sine și lista cu camerele. Ea verifică dacă datele de intrare sunt valide conform condițiilor impuse de problema și returnează True dacă da și False dacă nu.

#2 A doua funcție, poate_fi_inchiriata(n: int, matrice: list, x: int, y: int) -> bool, verifică dacă o cameră de la coordonatele x, y poate fi închiriată, folosind o căutare în adâncime (DFS) începând cu acea cameră. Dacă se găsește o succesiune de camere libere care începe pe o latură a clădirii și se încheie la camera respectivă, atunci camera poate fi închiriată, altfel nu.

#3 Ultima funcție, main(), citeste datele de intrare din fișierul iesire.in, validează datele, apoi aplică funcția poate_fi_inchiriata() pentru fiecare cameră și scrie rezultatele în fișierul iesire.out.