1979 - Rb Tree

Enunț

Gigel se joacă cu un graf orientat cu N noduri. Inițial toate nodurile grafului sunt transparente, dar lui Gigel îi place schimbarea. Fire ambițioasă, el colorează unele noduri în roșu, altele în negru, iar pe celelalte în alb (probabil din cauza crizei de vopsea colorată din 2017).

Gigel recrutează o armată de furnici pe care o așează în nodul 1, cu el în fruntea lor și se hotărăște să cucerească graful.În fiecare moment, Gigel poate trimite un număr de furnici din orice nod X (în care se află deja furnici) în vecinii lui X, cu condiția ca cel puțin o furnică să rămână în nodul X. Excepție de la această regulă face nodul 1, cel în care se află Gigel, unde nu este obligatoriu să rămână furnici.

Dacă într-un nod se află Gigel sau cel puțin o furnică, atunci acel nod se numește ocupat. Graful este cucerit atunci când Gigel a ocupat cel puțin un nod roșu și cel puțin un nod negru.

Cerința

Sa se determine numărul minim de furnici pentru ca Gigel să cucerească graful.

Date de intrare

Fișierul de intrare rbtreeIN.txt conține pe prima linie trei numere naturale: N – reprezentând numărul de noduri ale grafului, R – reprezentând numărul nodurilor de culoare roșie și B – reprezentând numărul nodurilor de culoare neagră.

A doua linie conține R numere distincte r1, r2, …, rR, reprezentând nodurile roșii.

A treia linie conține B numere distincte b1, b2, …, bB, reprezentând nodurile negre.

Următoarele N linii descriu nodurile grafului împreună cu vecinii lor. Pe linia i+3 se află vecinii nodului i și este formată din:

- un număr P, reprezentând numărul de vecini ai nodului i

- P numere distincte n1, n2, … , nP reprezentând vecinii nodului

Date de ieșire

Fișierul de ieșire rbtreeOUT.txt va conține o singură linie pe care se află numărul minim de furnici pentru ca Gigel să cucerească graful. În cazul în care graful nu poate fi cucerit, se va afișa mesajul impossible.În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

Restricții și precizări

• 2 ≤ N ≤ 100.000
• 1 ≤ R < N
• 1 ≤ B < N
• 1 ≤ ri ≤ N, pentru oricare i, 1 ≤ i ≤ R
• 1 ≤ bi ≤ N, pentru oricare i, 1 ≤ i ≤ B
• 0 ≤ P ≤ 10
• 1 ≤ ni ≤ N, pentru oricare 1 ≤ i ≤ P
• Se garantează că un nod are o singură culoare. Dacă un nod nu este roșu sau negru, atunci este alb.
• Gigel rămâne tot timpul în nodul 1, deci nodul 1 este ocupat.

Exemplul 1:

rbtreeIN.txt

3 1 1
2
3
1 2
2 3 1
1 1

rbtreeOUT.txt

2

Exemplul 2:

rbtreeIN.txt

100001 1 1
2
3
1 2
2 3 1
1 1

rbtreeOUT.txt

Datele nu corespund restrictiilor impuse

Rezolvare

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

INF = 99999999 NR = 100005

def check_restrictions(n, RED, BLACK, red_nodes, black_nodes, p_values):

   if not (2 <= n <= 100000 and 1 <= RED < n and 1 <= BLACK < n):
       return "Datele nu corespund restrictiilor impuse"

   for x in red_nodes + black_nodes:
       if not (1 <= x <= n):
           return "Datele nu corespund restrictiilor impuse"

   for ni in p_values:
       if not (1 <= ni <= n):
           return "Datele nu corespund restrictiilor impuse"

   return None  # All restrictions are satisfied

def BFS(q, dist, graph):

   while q:
       k = q.popleft()
       for x in graph[k]:
           if dist[x] > dist[k] + 1:
               dist[x] = dist[k] + 1
               q.append(x)

def process_input(filename):

   try:
       with open(filename, "r") as f:
           n, RED, BLACK = map(int, f.readline().split())

           restriction_result = check_restrictions(n, RED, BLACK, [], [], [])
           if restriction_result:
               return restriction_result

           redQueue = deque()
           blackQueue = deque()
           rootQueue = deque()
           v = [[] for _ in range(NR)]
           vt = [[] for _ in range(NR)]

           redDist = [INF] * NR
           blackDist = [INF] * NR
           rootDist = [INF] * NR

           line = list(map(int, f.readline().split()))
           for i in range(RED):
               x = line[i]
               redDist[x] = 0
               redQueue.append(x)

           line = list(map(int, f.readline().split()))
           for i in range(BLACK):
               x = line[i]
               blackDist[x] = 0
               blackQueue.append(x)

           for i in range(1, n + 1):
               line = list(map(int, f.readline().split()[1:]))
               for x in line:
                   v[i].append(x)
                   vt[x].append(i)

           rootDist[1] = 0
           rootQueue.append(1)

           BFS(redQueue, redDist, vt)
           BFS(blackQueue, blackDist, vt)
           BFS(rootQueue, rootDist, v)

           minn = INF
           for i in range(1, n + 1):
               minn = min(minn, redDist[i] + blackDist[i] + rootDist[i])

           if minn == INF:
               return "impossible\n"
           else:
               return str(minn) + "\n"

   except Exception as e:
       return str(e)

def main():

   input_filename = "rbtreeIN.txt"
   output_filename = "rbtreeOUT.txt"

   result = process_input(input_filename)

   with open(output_filename, "w") as g:
       g.write(result)

if __name__ == "__main__":

   main()

</syntaxhighlight>