Editing 1979 - Rb Tree

== Enunț ==
Gigel se joacă cu un graf orientat cu <code>N</code> 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 <code>1</code>, 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 <code>X</code> (în care se află deja furnici) în vecinii lui <code>X</code>, cu condiția ca cel puțin o furnică să rămână în nodul <code>X</code>. Excepție de la această regulă face nodul <code>1</code>, 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 <code>rbtreeIN.txt</code> conține pe prima linie trei numere naturale: <code>N</code> – reprezentând numărul de noduri ale grafului, <code>R</code> – reprezentând numărul nodurilor de culoare roșie și <code>B</code> – reprezentând numărul nodurilor de culoare neagră.

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

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

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

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

- <code>P</code> numere distincte <code>n1</code>, <code>n2</code>, <code>…</code> , <code>nP</code> reprezentând vecinii nodului

= Date de ieșire =
Fișierul de ieșire <code>rbtreeOUT.txt</code> 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 <code>impossible</code>.În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

= Restricții și precizări =

* <code>2 ≤ N ≤ 100.000</code>
* <code>1 ≤ R < N</code>
* <code>1 ≤ B < N</code>
* <code>1 ≤ ri ≤ N</code>, pentru oricare <code>i</code>, <code>1 ≤ i ≤ R</code>
* <code>1 ≤ bi ≤ N</code>, pentru oricare <code>i</code>, <code>1 ≤ i ≤ B</code>
* <code>0 ≤ P ≤ 10</code>
* <code>1 ≤ ni ≤ N</code>, pentru oricare <code>1 ≤ i ≤ P</code>
* 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 <code>1</code>, deci nodul <code>1</code> este ocupat.

= Exemplul 1: =
<code>rbtreeIN.txt</code>
 3 1 1
 2
 3
 1 2
 2 3 1
 1 1
<code>rbtreeOUT.txt</code>
 2

= Exemplul 2: =
<code>rbtreeIN.txt</code>
 100001 1 1
 2
 3
 1 2
 2 3 1
 1 1
<code>rbtreeOUT.txt</code>
 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>