Editing 1758 - Bile 3

== Enunt ==
Matei a inventat un nou joc cu bile. Terenul de joc este o tablă dreptunghiulară aşezată vertical. Tabla este împărţită în m*n celule, aşezate în m linii şi n coloane. În unele dintre celule se află obstacole.

De sus, din celulele aflate pe prima linie, sunt lăsate să cadă bile. Bilele cad vertical până la întâlnirea unui obstacol sau până în celula cea mai de jos din coloana pe care se află. Prima bilă care loveşte un obstacol se deplasează pe orizontală în coloana alăturată din stânga, apoi îşi continuă căderea. Fiecare dintre celelalte bile care lovesc acelaşi obstacol se deplasează pe orizontală, în coloana alăturată, dar în direcţie opusă faţă de bila care a lovit acest obstacol exact înaintea lor, apoi îşi continuă căderea.
== Cerinţa ==
Cunoscând numărul de bile lăsate să cadă de pe fiecare celulă a primei linii şi poziţia obstacolelor, determinaţi numărul de bile ajunse în fiecare celulă a ultimei linii. Poziţiile obstacolelor sunt indicate prin linia şi coloana lor (colţul din stânga sus corespunde liniei 1 şi coloanei 1).
== Date de intrare ==
Fişierul bile.in conţine pe prima linie, separate prin câte un spaţiu, numerele naturale m, n şi p (numărul de linii, numărul de coloane şi numărul de obstacole). Următoarele p linii conţin câte două numere, separate de câte un spaţiu, reprezentând poziţiile celor p obstacole. Ultimele n linii conţin câte un număr natural, reprezentând numărul bilelor lansate din fiecare celulă a primei linii (începând cu prima celulă de pe linie).
== Date de ieșire ==
Fişierul de ieşire bile.out va conţine n linii cu câte un număr, acesta reprezentând numărul de bile din fiecare celulă a ultimei linii (începând cu prima celulă de pe această linie).
== Restricţii şi precizări ==
* 2 ≤ m,n ≤ 2000
* 0 ≤ p ≤ 10.000
* Se lansează maximum 1000 de bile din fiecare celulă;
* Pe prima şi ultima linie, respectiv prima şi ultima coloană, nu există obstacole;
* Nu există două obstacole alăturate pe linie, coloană sau diagonală.
== Exemplu ==
; bile.in
 6 7 5
 2 3
 2 5
 4 2
 4 4
 5 6
 4
 6
 4
 5
 8
 3
 5 
; bile.out
 8
 0
 10
 0
 9
 0
 8
<br>

== Rezolvare ==
<syntaxhighlight lang="python" line>
def simulate_balls(m, n, p, obstacles, balls):
    # Inițializăm matricea pentru terenul de joc
    board = [[0] * n for _ in range(m)]
    
    # Adăugăm obstacolele pe tablă
    for obstacle in obstacles:
        x, y = obstacle
        board[x - 1][y - 1] = 1
    
    # Inițializăm vectorul pentru bilele lăsate să cadă de pe prima linie
    first_row_balls = balls
    
    # Iterăm prin fiecare coloană, de la stânga la dreapta
    for j in range(n):
        # Numărăm câte bile au ajuns în fiecare celulă de pe ultima linie
        for i in range(m):
            if i == m - 1:
                # Dacă suntem pe ultima linie, adăugăm numărul de bile lăsate să cadă din coloana j
                board[i][j] += first_row_balls[j]
            else:
                # Dacă nu suntem pe ultima linie, simulăm căderea bilelor
                if board[i][j] > 0:
                    # Bila va cădea în jos până întâlnește un obstacol sau ajunge pe ultima linie
                    k = i + 1
                    while k < m and board[k][j] == 0:
                        k += 1
                    # Dacă am întâlnit un obstacol, bilele se vor deplasa pe orizontală
                    if k < m:
                        if j > 0 and board[k][j - 1] == 1:
                            board[k][j - 1] += board[i][j]
                        if j < n - 1 and board[k][j + 1] == 1:
                            board[k][j + 1] += board[i][j]
                    else:
                        # Dacă am ajuns pe ultima linie, adăugăm bilele în acea celulă
                        board[k - 1][j] += board[i][j]
    
    # Extragem numărul de bile din fiecare celulă de pe ultima linie
    last_row_balls = board[-1]
    
    return last_row_balls

def main():
    # Citim datele de intrare din fișier
    with open("bile.in", "r") as fin:
        m, n, p = map(int, fin.readline().split())
        obstacles = [tuple(map(int, fin.readline().split())) for _ in range(p)]
        balls = [int(fin.readline()) for _ in range(n)]

    # Simulăm căderea bilelor
    last_row_balls = simulate_balls(m, n, p, obstacles, balls)

    # Scriem rezultatul în fișierul de ieșire
    with open("bile.out", "w") as fout:
        fout.write("\n".join(map(str, last_row_balls)) + "\n")

if __name__ == "__main__":
    main()

</syntaxhighlight>