3404 - castel3: Difference between revisions

From Bitnami MediaWiki
Pagină nouă: == Enunt == Înspăimântătorii tăi luptători au răpit-o pe Prinţesa Ghiocela şi au închis-o în castelul tău de pe vârful Muntelui Pleşuv. Deoarece eşti un geniu malefic, te-ai hotărât să îi oferi prinţesei iluzia unei şanse de evadare. Castelul tău are forma unui caroiaj cu M linii şi N coloane. Cele M x N celule ale castelului sunt numerotate de la 1 la M x N în ordinea parcurgerii caroiajului pe linii de sus în jos, iar pe aceeaşi linie în ordinea...
 
No edit summary
 
Line 2: Line 2:


Înspăimântătorii tăi luptători au răpit-o pe Prinţesa Ghiocela şi au închis-o în castelul tău de pe vârful Muntelui Pleşuv. Deoarece eşti un geniu malefic, te-ai hotărât să îi oferi prinţesei iluzia unei şanse de evadare.
Înspăimântătorii tăi luptători au răpit-o pe Prinţesa Ghiocela şi au închis-o în castelul tău de pe vârful Muntelui Pleşuv. Deoarece eşti un geniu malefic, te-ai hotărât să îi oferi prinţesei iluzia unei şanse de evadare.
Castelul tău are forma unui caroiaj cu M linii şi N coloane. Cele M x N celule ale castelului sunt numerotate de la 1 la M x N în ordinea parcurgerii caroiajului pe linii de sus în jos, iar pe aceeaşi linie în ordinea coloanelor de la stânga la dreapta. În fiecare dintre celulele castelului ai pus câte o cheie, mai precis celula i conţine cheia cu numărul i. Evident, pentru a intra într-o cameră, prinţesa are nevoie de o anume cheie care permite deschiderea acesteia. Mai mult, dintr-o cameră prinţesa se poate deplasa într-un moment numai într-una dintre cele maximum patru camere adiacente pe orizontală şi verticală, doar dacă deţine cheia necesară deschiderii sale. Odată ce a intrat într-o cameră şi a obţinut o cheie, prinţesa o păstrează şi poate să o utilizeze ori de câte ori doreşte.


== Cerinta ==
Castelul tău are forma unui caroiaj cu <code>M</code> linii şi <code>N</code> coloane. Cele <code>M x N</code> celule ale castelului sunt numerotate de la <code>1</code> la <code>M x N</code> în ordinea parcurgerii caroiajului pe linii de sus în jos, iar pe aceeaşi linie în ordinea coloanelor de la stânga la dreapta. În fiecare dintre celulele castelului ai pus câte o cheie, mai precis celula <code>i</code> conţine cheia cu numărul <code>i</code>. Evident, pentru a intra într-o cameră, prinţesa are nevoie de o anume cheie care permite deschiderea acesteia. Mai mult, dintr-o cameră prinţesa se poate deplasa într-un moment numai într-una dintre cele maximum patru camere adiacente pe orizontală şi verticală, doar dacă deţine cheia necesară deschiderii sale. Odată ce a intrat într-o cameră şi a obţinut o cheie, prinţesa o păstrează şi poate să o utilizeze ori de câte ori doreşte.


Deşi eşti convins că prinţesa nu va scăpa din castel, eşti curios să afli câte dintre cele M x N camere îi sunt accesibile. Date fiind dimensiunile castelului, camera în care se află iniţial prinţesa şi cheile necesare deschiderii fiecăreia dintre camere, află răspunsul la această întrebare presantă.
= Cerința =
Deşi eşti convins că prinţesa nu va scăpa din castel, eşti curios să afli câte dintre cele <code>M x N</code> camere îi sunt accesibile. Date fiind dimensiunile castelului, camera în care se află iniţial prinţesa şi cheile necesare deschiderii fiecăreia dintre camere, află răspunsul la această întrebare presantă.


== Date de intrare ==
= Date de intrare =
Fișierul de intrare <code>castelIN.txt</code> conţine pe prima linie trei numere naturale <code>M N K</code> separate prin câte un spaţiu reprezentând dimensiunile castelului, respectiv numărul camerei în care se află iniţial prinţesa. Urmează descrierea castelului. Pe fiecare dintre următoarele <code>M</code> linii se află câte <code>N</code> numere naturale cuprinse între <code>1</code> şi <code>M x N</code> reprezentând cheile necesare deschiderii fiecăreia dintre camere.


Fișierul de intrare castel.in conţine pe prima linie trei numere naturale M N K separate prin câte un spaţiu reprezentând dimensiunile castelului, respectiv numărul camerei în care se află iniţial prinţesa. Urmează descrierea castelului. Pe fiecare dintre următoarele M linii se află câte N numere naturale cuprinse între 1 şi M x N reprezentând cheile necesare deschiderii fiecăreia dintre camere.
= Date de ieșire =
Fișierul de ieșire <code>castelOUT.txt</code> va conţine o singură linie pe care va fi scris un singur număr natural reprezentând numărul de camere accesibile prinţesei.


== Date de ieșire ==
= Restricții și precizări =


Fișierul de ieșire castel.out va conţine o singură linie pe care va fi scris un singur număr natural reprezentând numărul de camere accesibile prinţesei.
* <code>1 ≤ M, N ≤ 150</code>
* <code>1 ≤ K ≤ M * N</code>
* Odată ce prinţesa a păşit într-o cameră, respectiva cameră va rămâne pentru totdeauna deschisă.


== Restricții și precizări ==
= Exemplul 1: =
<code>castelIN.txt</code>
4 3 1
1 1 4
1 6 2
6 9 8
12 10 11
<code>castelOUT.txt</code>
7


*1 ≤ M, N ≤ 150
= Exemplul 1: =
*1 ≤ K ≤ M * N
<code>castelIN.txt</code>
*Odată ce prinţesa a păşit într-o cameră, respectiva cameră va rămâne pentru totdeauna deschisă.
151 3 1
1 1 4
1 6 2
6 9 8
12 10 11
<code>castelOUT.txt</code>
Datele nu corespund restrictiilor impuse


== Exemplul 1 ==
=== Explicație ===
 
Prinţesa porneşte din camera <code>1</code>. Aici foloseşe cheia <code>1</code> şi intră în camera <code>4</code>. Se întoarce în camera <code>1</code> şi descuie camera <code>2</code>. Foloseşte cheia luată din camera <code>4</code> şi descuie camera <code>3</code>. În acest moment ea deţine cheile <code>1</code>, <code>2</code>, <code>3</code> şi <code>4</code>. Foloseşte cheia <code>2</code> şi intră în camera <code>6</code>, apoi foloseşte cheia <code>6</code> şi intră în camera <code>5</code>, apoi în camera <code>4</code>, de unde, folosind cheia luată din camera <code>6</code> intră în camera <code>7</code>. La final prinţesa are cheile <code>1</code>, <code>2</code>, <code>3</code>, <code>4</code>, <code>5</code>, <code>6</code>, <code>7</code> şi nu mai poate deschide nici o altă cameră.
;castelin.txt
:
 
:4 3 1
 
:1 1 4
 
:1 6 2
 
:6 9 8
 
:12 10 11
 
;castelout.txt
 
:Datele introduse corespund restrictiilor impuse.
 
:7
 
== Exemplul 2 ==
 
;castelin.txt
 
:0 8 9
 
:-2 -3 -4
 
:123  433 4322
 
:9383 -12 -2
 
:-098 -9087 0
 
;castelout.txt
 
:Datele de intrare nu corespund restrictiilor impuse.


== Rezolvare ==
== Rezolvare ==


<syntaxhighlight lang="python3" line="1">
<syntaxhighlight lang="python3" line="1">
from collections import deque


def numar_camere_accesibile(M, N, camera_initiala, chei_necesare):
def verifica_restrictii(n, m, cam):
     # Pasul 1: Construirea grafului
     if not (1 <= n <= 150 and 1 <= m <= 150 and 1 <= cam <= n * m):
    graf = construieste_graf(M, N, chei_necesare)
        with open("castelOUT.txt", "w") as fout:
 
            fout.write("Datele nu corespund restrictiilor impuse\n")
    # Pasul 2: Căutarea în graf
         return False
    chei_prințesa = set()
    return True
    camere_accesibile = set()
 
    def dfs(camera):
        nonlocal chei_prințesa, camere_accesibile
        camere_accesibile.add(camera)
 
         for vecin in graf[camera]:
            cheie_necesara = graf[camera][vecin]
            if cheie_necesara in chei_prințesa:
                if vecin not in camere_accesibile:
                    dfs(vecin)


    dfs(camera_initiala)
def main():
    di = [0, 0, 1, -1]
    dj = [1, -1, 0, 0]
    N = 155


     # Pasul 3: Numărăm camerele accesibile
     with open("castelIN.txt", "r") as fin:
    return len(camere_accesibile)
        n, m, cam = map(int, fin.readline().split())
        if not verifica_restrictii(n, m, cam):
            return
        mat = [[0] * (m + 1) for _ in range(n + 1)]
        for i in range(1, n + 1):
            mat[i][1:m + 1] = map(int, fin.readline().split())


def construieste_graf(M, N, chei_necesare):
    sx = cam // m + 1
     graf = {}
     sy = cam % m
     for i in range(1, M * N + 1):
     if cam % m == 0:
         graf[i] = {}
        sx -= 1
         sy = m


     for i in range(1, M + 1):
     q = deque([(sx, sy)])
        for j in range(1, N + 1):
    viz = [False] * (N * N)
            camera = (i - 1) * N + j
    deja = [[False] * (m + 1) for _ in range(n + 1)]
    astept = [[] for _ in range(N * N)]


            # Verificăm camerele adiacente pe orizontală și verticală
    while q:
            if i > 1:
        x, y = q.popleft()
                vecin = camera - N
        CAM = (x - 1) * m + y
                cheie = chei_necesare[vecin - 1]
        deja[x][y] = viz[CAM] = True
                graf[camera][vecin] = cheie
                graf[vecin][camera] = cheie


             if i < M:
        for cam in astept[CAM]:
                 vecin = camera + N
            ny = cam % m
                 cheie = chei_necesare[camera - 1]
            nx = cam // m + 1
                graf[camera][vecin] = cheie
             if cam % m == 0:
                 graf[vecin][camera] = cheie
                 nx -= 1
                 ny = m
            if not deja[nx][ny]:
                 q.append((nx, ny))
       
        astept[CAM].clear()


             if j > 1:
        for dir in range(4):
                vecin = camera - 1
            nx = x + di[dir]
                 cheie = chei_necesare[vecin - 1]
            ny = y + dj[dir]
                graf[camera][vecin] = cheie
            cam = (nx - 1) * m + ny
                 graf[vecin][camera] = cheie
             if 1 <= nx <= n and 1 <= ny <= m:
                 if viz[mat[nx][ny]]:
                    if not deja[nx][ny]:
                        q.append((nx, ny))
                 else:
                    astept[mat[nx][ny]].append(cam)


            if j < N:
    res = sum(deja[i][j] for i in range(1, n + 1) for j in range(1, m + 1))
                vecin = camera + 1
                cheie = chei_necesare[camera - 1]
                graf[camera][vecin] = cheie
                graf[vecin][camera] = cheie


     return graf
     with open("castelOUT.txt", "w") as fout:
        fout.write(str(res) + "\n")


rezultat = numar_camere_accesibile(M, N, camera_initiala, chei_necesare)
if __name__ == "__main__":
print(rezultat)
    main()


</syntaxhighlight>
</syntaxhighlight>

Latest revision as of 20:53, 22 March 2024

Enunt[edit | edit source]

Înspăimântătorii tăi luptători au răpit-o pe Prinţesa Ghiocela şi au închis-o în castelul tău de pe vârful Muntelui Pleşuv. Deoarece eşti un geniu malefic, te-ai hotărât să îi oferi prinţesei iluzia unei şanse de evadare.

Castelul tău are forma unui caroiaj cu M linii şi N coloane. Cele M x N celule ale castelului sunt numerotate de la 1 la M x N în ordinea parcurgerii caroiajului pe linii de sus în jos, iar pe aceeaşi linie în ordinea coloanelor de la stânga la dreapta. În fiecare dintre celulele castelului ai pus câte o cheie, mai precis celula i conţine cheia cu numărul i. Evident, pentru a intra într-o cameră, prinţesa are nevoie de o anume cheie care permite deschiderea acesteia. Mai mult, dintr-o cameră prinţesa se poate deplasa într-un moment numai într-una dintre cele maximum patru camere adiacente pe orizontală şi verticală, doar dacă deţine cheia necesară deschiderii sale. Odată ce a intrat într-o cameră şi a obţinut o cheie, prinţesa o păstrează şi poate să o utilizeze ori de câte ori doreşte.

Cerința[edit | edit source]

Deşi eşti convins că prinţesa nu va scăpa din castel, eşti curios să afli câte dintre cele M x N camere îi sunt accesibile. Date fiind dimensiunile castelului, camera în care se află iniţial prinţesa şi cheile necesare deschiderii fiecăreia dintre camere, află răspunsul la această întrebare presantă.

Date de intrare[edit | edit source]

Fișierul de intrare castelIN.txt conţine pe prima linie trei numere naturale M N K separate prin câte un spaţiu reprezentând dimensiunile castelului, respectiv numărul camerei în care se află iniţial prinţesa. Urmează descrierea castelului. Pe fiecare dintre următoarele M linii se află câte N numere naturale cuprinse între 1 şi M x N reprezentând cheile necesare deschiderii fiecăreia dintre camere.

Date de ieșire[edit | edit source]

Fișierul de ieșire castelOUT.txt va conţine o singură linie pe care va fi scris un singur număr natural reprezentând numărul de camere accesibile prinţesei.

Restricții și precizări[edit | edit source]

  • 1 ≤ M, N ≤ 150
  • 1 ≤ K ≤ M * N
  • Odată ce prinţesa a păşit într-o cameră, respectiva cameră va rămâne pentru totdeauna deschisă.

Exemplul 1:[edit | edit source]

castelIN.txt

4 3 1
1 1 4
1 6 2
6 9 8
12 10 11

castelOUT.txt

7

Exemplul 1:[edit | edit source]

castelIN.txt

151 3 1
1 1 4
1 6 2
6 9 8
12 10 11

castelOUT.txt

Datele nu corespund restrictiilor impuse

Explicație[edit | edit source]

Prinţesa porneşte din camera 1. Aici foloseşe cheia 1 şi intră în camera 4. Se întoarce în camera 1 şi descuie camera 2. Foloseşte cheia luată din camera 4 şi descuie camera 3. În acest moment ea deţine cheile 1, 2, 3 şi 4. Foloseşte cheia 2 şi intră în camera 6, apoi foloseşte cheia 6 şi intră în camera 5, apoi în camera 4, de unde, folosind cheia luată din camera 6 intră în camera 7. La final prinţesa are cheile 1, 2, 3, 4, 5, 6, 7 şi nu mai poate deschide nici o altă cameră.

Rezolvare[edit | edit source]

<syntaxhighlight lang="python3" line="1"> from collections import deque

def verifica_restrictii(n, m, cam):

   if not (1 <= n <= 150 and 1 <= m <= 150 and 1 <= cam <= n * m):
       with open("castelOUT.txt", "w") as fout:
           fout.write("Datele nu corespund restrictiilor impuse\n")
       return False
   return True

def main():

   di = [0, 0, 1, -1]
   dj = [1, -1, 0, 0]
   N = 155
   with open("castelIN.txt", "r") as fin:
       n, m, cam = map(int, fin.readline().split())
       if not verifica_restrictii(n, m, cam):
           return
       mat = [[0] * (m + 1) for _ in range(n + 1)]
       for i in range(1, n + 1):
           mat[i][1:m + 1] = map(int, fin.readline().split())
   sx = cam // m + 1
   sy = cam % m
   if cam % m == 0:
       sx -= 1
       sy = m
   q = deque([(sx, sy)])
   viz = [False] * (N * N)
   deja = [[False] * (m + 1) for _ in range(n + 1)]
   astept = [[] for _ in range(N * N)]
   while q:
       x, y = q.popleft()
       CAM = (x - 1) * m + y
       deja[x][y] = viz[CAM] = True
       for cam in astept[CAM]:
           ny = cam % m
           nx = cam // m + 1
           if cam % m == 0:
               nx -= 1
               ny = m
           if not deja[nx][ny]:
               q.append((nx, ny))
       
       astept[CAM].clear()
       for dir in range(4):
           nx = x + di[dir]
           ny = y + dj[dir]
           cam = (nx - 1) * m + ny
           if 1 <= nx <= n and 1 <= ny <= m:
               if viz[mat[nx][ny]]:
                   if not deja[nx][ny]:
                       q.append((nx, ny))
               else:
                   astept[mat[nx][ny]].append(cam)
   res = sum(deja[i][j] for i in range(1, n + 1) for j in range(1, m + 1))
   with open("castelOUT.txt", "w") as fout:
       fout.write(str(res) + "\n")

if __name__ == "__main__":

   main()

</syntaxhighlight>