Editing 1642 - Culegere

Pădurea magică din Povestea lui Negrimon este situată pe un teren dreptunghiular care poate fi privit ca o matrice cu <code>N</code> linii, numerotate de la <code>1</code> la <code>N</code> şi <code>M</code> coloane, numerotate de la <code>1</code> la <code>M</code>. Putem spune că terenul este împărţit în <code>N * M</code>

parcele pătrate de latură <code>1</code>. În pădure trăieşte şarpele Snake care, iniţial, este lung cât <code>K</code> parcele şi lat cât una singură. La începutul poveştii şarpele se află pe prima linie, pe parcelele de la <code>1</code> la <code>K</code>, capul fiind pe poziţia <code>K</code> şi orientat spre est.

Snake se deplasează cu o parcelă pe secundă. Astfel, după prima secundă, şarpele se va afla tot pe linia <code>1</code>, deplasat cu o poziţie spre dreapta, mai exact capul va fi în parcela <code>K + 1</code>. Deplasarea se face simultan cu întreg corpul.

În pădure au loc <code>E</code> evenimente ce pot fi de tipurile următoare:

# Apariţia unui măr la secunda <code>st</code> pe linia <code>x</code> şi coloana <code>y</code>, care va dispărea la secunda <code>en</code>, dacă nu este mâncat până atunci de şarpe. Snake înghite mărul când capul său ajunge în parcela care îl conţine. Mărul dispare, desigur, iar corpul şarpelui creşte instantaneu cu o unitate care îi va fi adăugată la coadă şi va ocupa aceeaşi parcelă pe care s-a aflat coada (ultima porţiune din corp) la secunda anterioară înghiţirii mărului.

# Apariţia unui schimbător la secunda <code>st</code> pe linia <code>x</code> şi coloana <code>y</code>, care va dispărea la secunda <code>en</code> şi care are valoarea <code>v</code>. Când capul şarpelui ajunge în parcela schimbătorului, direcţia ulterioară de deplasare va fi dată de valoarea <code>v ∈ {1, 2, 3, 4}</code> cu semnificaţia: <code>1</code> Nord (sus); <code>2</code> Est (dreapta); <code>3</code> Sud (jos); <code>4</code> Vest (stânga).

Schimbătorul funcţionează astfel: de exemplu, dacă Snake se deplasează spre Est şi la o anumită secundă capul acestuia ajunge într-o parcelă unde se află un schimbător cu valoarea <code>1</code>, la următoarea secundă capul se va afla în parcela situată deasupra schimbătorului şi în parcela schimbătorului se află prima porţiune din corpul şarpelui.

Schimbătorul dispare exact în secunda <code>en</code> iar până atunci rămâne în matrice indiferent de câte ori Snake trece prin parcela acestuia. Schimbătorul va acţiona doar când capul lui Snake ajunge în parcela lui şi nu va exista nicio situaţie în care să se schimbe direcţia în sens opus celei din care vine. De exemplu, dacă direcţia lui Snake este spre Est, nu va întâlni un schimbător cu valoarea <code>4</code>, care l-ar întoarce spre Vest.

În fiecare secundă <code>s</code>, evenimentele se petrec în acestă ordine: dispar obiectele programate să dispară în secunda <code>s</code>, apar obiectele ce trebuie să apară în secunda <code>s</code>, Snake se deplasează cu o parcelă. Dacă printr-o combinaţie nefericită de mişcări, Snake se loveşte de propriul corp, el se blochează şi aşteptă serviciul de asistenţă a pădurii.

Deoarece Snake se află într-o pădure magică, deplasarea lui respectă reguli speciale: când capul este pe ultima coloană din matrice şi se mişcă spre Est, el reapare pe aceeaşi linie, dar pe prima coloană, trăgând corpul simultan. Analog şi pentru prima coloană, când se deplasează spre Vest, capul reapare pe aceeaşi linie dar pe ultima coloană. Dacă şarpele se află pe prima linie şi se deplasează spre Nord, mişcarea va continua pe ultima linie şi aceeaşi coloană din matrice. Analog pentru ultima linie, când Snake se deplasează spre Sud, capul reapare pe prima linie şi aceeaşi

coloană. Aceste mişcări au loc doar dacă Snake nu se blochează în propriul corp.

Povestea se termină în secunda în care apare oricare dintre situaţiile: Snake se loveşte de propriul corp, caz în care el rămâne BLOCAT; toate cele <code>E</code> evenimente s-au produs şi nu mai există niciun obiect în matrice pentru că toate au

dispărut, caz în care rămâne un şarpe LIBER.

= Cerința =
În funcţie de finalul poveştii, afişaţi starea lui Snake şi harta pădurii în secunda respectivă. Pe hartă trebuie să fie marcate parcelele ocupate de corpul lui Snake, inclusiv capul.

= Date de intrare =
Fișierul de intrare <code>culegere.in</code> conține pe prima linie valorile: <code>N</code> – numărul de linii, <code>M</code> – numărul de coloane în care este împărţită pădurea, K- lungimea şarpelui şi <code>E</code> – numărul de evenimente din pădure, separate prin câte un spaţiu.

Următoarele <code>E</code> linii respectă unul dintre formatele:

* <code>1 x y st en</code> – Apare un măr la secunda <code>st</code>, pe linia <code>x</code>, coloana <code>y</code> şi dispare la secunda <code>en</code>
* <code>2 x y st en v</code> – Apare un schimbător la secunda <code>st</code>, pe linia <code>x</code>, coloana <code>y</code>, dispare la secunda <code>en</code> şi are valoarea <code>v</code>. Evenimentele sunt sortate crescător în funcţie de <code>st</code>.

= Date de ieșire =
Fișierul de ieșire <code>culegere.out</code> va conține pe prima linie cuvântul <code>BLOCAT</code> sau <code>LIBER</code>, în funcţie de starea lui Snake la sfârşitul poveştii. Pe fiecare dintre următoarele <code>N</code> linii, se vor afla <code>M</code> caractere din mulţimea <code>{'.', 'O', '#'}</code>, cu

următoarea semnificaţie : <code>'.'</code> – parcelă liberă, majuscula <code>'O'</code> – parcelă în care se află o porţiune din corpul şarpelui, <code>'#'</code> – parcela în care se află capul lui Snake. Caracterul <code>'#'</code> va apărea o singură dată în matrice.

= Restricții și precizări =

* <code>2 ≤ N, M ≤ 2000; 2 ≤ K < M; 1 ≤ E ≤ 500.000;</code>
* <code>1 ≤ x ≤ N; 1 ≤ y ≤ M; 1 ≤ st < en ≤ 500.000; v ∈ {1,2,3,4}</code>
* Obiectele apar doar în parcele libere.
* Povestea începe la secunda <code>0</code>.

= Exemplul 1 =
<code>culegere.in</code>
 4 5 3 4
 1 1 5 1 5
 2 1 1 2 6 3
 2 2 1 2 5 2
 2 4 4 3 5 4
<code>culegere.out</code>
 LIBER
 O....
 OO#..
 .....
 .....

=== Explicație ===
'''Secunda 0:'''
 OO#..
 .....
 .....
 .....
'''Secunda 1:''' apare 1 măr, deplasare spre Est
 .OO#M
 .....
 .....
 .....
'''Secunda 2:''' apar <code>2</code> schimbătoare, deplasare spre Est, înghite măr, creşte coada
 3OOO#
 2....
 .....
 .....
'''Secunda 3:''' apare un schimbător pe <code>(4, 4)</code>, deplasare spre Est şi capul apare pe prima coloană peste schimbătorul <code>3</code> din poziţia <code>(1, 1)</code>
 #.OOO
 2....
 .....
 ....4
'''Secunda 4:''' Nu apar şi nu dispar obiecte, deplasare spre Sud, corpul urmează acelaşi traseu ca şi capul care a fost influenţat la secunda <code>3</code> de schimbătorul cu valoarea <code>3</code>; capul ajunge peste schimbătorul <code>2</code> de la poziţia <code>(2,1)</code>
 O..OO
 #....
 .....
 ....4
'''Secunda 5:''' dispare schimbătorul de la <code>(4, 4)</code>, deplasare spre Est deoarece capul a fost influenţat de schimbătorul cu valoarea <code>2</code> la secunda <code>4</code>; dacă mărul nu ar fi fost mâncat, acum ar fi dispărut
 O...O
 O#...
 .....
 .....
'''Secunda 6:''' dispare primul schimbător chiar dacă acesta a fost acoperit de corpul lui

Snake, deplasare spre Est
 O....
 OO#..
 .....
 .....
Aceasta este configuraţia finală deoarece acum a dispărut şi ultimul obiect. Snake nu s-a blocat în propriul corp, deci este LIBER.<syntaxhighlight lang="python" line="1">
from collections import deque

# Citire date de intrare
N, M = map(int, input().split())
K = int(input())
E = int(input())

events = []
for _ in range(E):
    st, x, y, t, en = input().split()
    st, x, y, en = int(st), int(x), int(y), int(en)
    if t.isdigit():
        t = int(t)
    events.append((st, x-1, y-1, t, en))

# Direcții: Nord (1), Est (2), Sud (3), Vest (4)
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # E, S, W, N

# Inițializare șarpe
snake = deque([(0, i) for i in range(K)])
head = (0, K-1)
direction = 0  # Inițial est (E)
occupied = set(snake)

# Evenimente active
active_apples = {}
active_switchers = {}

# Stare șarpe
snake_alive = True
time = 0

def move_snake():
    global head, direction
    new_head = ((head[0] + directions[direction][0]) % N, (head[1] + directions[direction][1]) % M)
    if new_head in occupied:
        return False
    occupied.add(new_head)
    snake.append(new_head)
    if new_head in active_apples:
        occupied.add(snake[-1])
        active_apples.pop(new_head)
    else:
        tail = snake.popleft()
        occupied.remove(tail)
    head = new_head
    if new_head in active_switchers:
        direction = active_switchers[new_head]
    return True

# Simulare
while snake_alive and events:
    # Elimina evenimentele care expira la timpul actual
    for pos in list(active_apples.keys()):
        if active_apples[pos] == time:
            active_apples.pop(pos)
    for pos in list(active_switchers.keys()):
        if active_switchers[pos][1] == time:
            active_switchers.pop(pos)

    # Adaugă evenimente noi
    while events and events[0][0] == time:
        st, x, y, t, en = events.pop(0)
        if isinstance(t, int):
            active_switchers[(x, y)] = (t-1, en)
        else:
            active_apples[(x, y)] = en

    # Deplasare șarpe
    snake_alive = move_snake()
    time += 1

# Rezultate
if snake_alive:
    print("LIBER")
else:
    print("BLOCAT")

# Harta finală
forest = [['.' for _ in range(M)] for _ in range(N)]
for x, y in snake:
    forest[x][y] = 'S'
forest[head[0]][head[1]] = 'H'

for line in forest:
    print(''.join(line))
</syntaxhighlight>