1691 - Arbore 1

Cerința

Se dă un arbore (graf conex aciclic) cu N noduri. Vrem să eliminăm noduri (împreună cu muchiile adiacente) din arborele dat, astfel încât numărul de componente conexe ale grafului rămas să fie maxim. Aflați care este numărul maxim de componente conexe pe care le putem obține și câte submulțimi distincte de noduri se pot elimina din arbore astfel încât să rămână la final acest număr maxim de componente conexe.

Date de intrare

Fișierul de intrare arbore1IN.txt conține pe prima linie numărul natural N, reprezentând numărul de noduri ale arborelui. Pe următoarele N-1 linii se vor afla câte două numere X și Y, cu semnificația că există o muchie între nodurile X și Y.

Date de ieșire

Fișierul de ieșire arbore1OUT.txt va conține pe prima linie două numere naturale reprezentând numărul maxim de componente conexe pe care îl putem obține, respectiv numărul de moduri în care putem obține acest număr de componente conexe modulo 10^9+7 (adică restul împărțirii acestui număr la 1000000007).În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

Restricții și precizări

• 1 ≤ N ≤ 100 000
• Se acordă 40% din punctajul unui test dacă numărul maxim de componente conexe este corect.
• Se acordă 60% din punctajul unui test dacă numărul de moduri este corect.
• Pentru 20% din teste N ≤ 20
• Pentru alte 30% din teste N ≤ 1000

Exemplul 1:

arbore1IN.txt

6
1 2
1 3
1 4
4 5
4 6

arbore1OUT.txt

4 1

Explicație

Se șterg nodurile 1 și 4. Nicio altă submulțime de noduri șterse nu produce 4 sau mai multe componente conexe.

Exemplul 2

arbore1IN.txt

100001
1 2
1 3
1 4
4 5
4 6

arbore1OUT.txt

Datele nu corespund restrictiilor impuse

Rezolvare

from collections import defaultdict

N = 100100
mod = 1000000007

v = defaultdict(list)
D = [[0] * N for _ in range(3)]
W = [[1] * N for _ in range(3)]

def check_constraints(n):
    if not (1 <= n <= 100000):
        with open("arbore1OUT.txt", "w") as output_file:
            output_file.write("Datele nu corespund restrictiilor impuse")
        exit()

def dfs(x, p):
    D[1][x] = 1
    D[0][x] = 0
    D[2][x] = 1
    W[1][x] = 1
    W[0][x] = 1
    W[2][x] = 1
    
    for it in v[x]:
        if it != p:
            dfs(it, x)
    
    # Cazul 1. Stergem nodul
    for it in v[x]:
        if it != p:
            D[0][x] += D[2][it]
            W[0][x] *= W[2][it]
            W[0][x] %= mod
    
    # Cazul 2. Nu stergem nodul
    for it in v[x]:
        if it != p:
            if D[0][it] + 1 == D[1][it]:
                W[1][x] *= (W[0][it] + W[1][it]) % mod
                W[1][x] %= mod
                D[1][x] += D[0][it]
            elif D[0][it] + 1 < D[1][it]:
                W[1][x] *= W[1][it]
                W[1][x] %= mod
                D[1][x] += D[1][it] - 1
            else:
                W[1][x] *= W[0][it]
                W[1][x] %= mod
                D[1][x] += D[0][it]
    
    # Calculam solutia pentru acest subarbore stiind cele 2 cazuri
    D[2][x] = max(D[1][x], D[0][x])
    if D[1][x] == D[0][x]:
        W[2][x] = (W[1][x] + W[0][x]) % mod
    elif D[1][x] > D[0][x]:
        W[2][x] = W[1][x]
    else:
        W[2][x] = W[0][x]

def main():
    with open("arbore1IN.txt", "r") as input_file:
        n = int(input_file.readline().strip())
        check_constraints(n)
        
        for _ in range(n-1):
            x, y = map(int, input_file.readline().strip().split())
            v[x].append(y)
            v[y].append(x)

    dfs(1, 0)

    with open("arbore1OUT.txt", "w") as output_file:
        output_file.write(f"{D[2][1]} {W[2][1]}")

if __name__ == "__main__":
    main()