# PBinfo #2282 – ComponenteConexe4 – Rezolvare C++

Sursa: Codul lui Andrei
Limbaj: C++
Autor rezolvare: Darius

## Enunț

Se consideră un graf neorientat cu n vârfuri și m muchii. Cele m muchii se elimină pe rând din graf.

Cerința
Pentru fiecare muchie eliminată trebuie să spuneți câte componente conexe are graful.

Date de intrare
Programul citește de la tastatură numerele n și m, iar pe următoarele m linii se află câte două valori x și y separate prin spațiu, reprezentând o muchie din graf. Muchiile vi se dau în ordinea în care ele se elimină din graf.

Date de ieșire
Programul va afișa pe ecran exact m linii, pe fiecare linie i aflându-se un singur număr natural reprezentând numărul componentelor conexe din graf după eliminarea celei de-a i-a muchii.

Restricții și precizări

1 ≤ n ≤ 100 000
1 ≤ m ≤ 500 000
Între două vârfuri va exista cel mult o muchie

Exemplu:
Intrare

5 6
1 2
3 4
2 3
1 5
5 4
4 1
Ieșire

1
2
3
3
4
5
Explicație
Sunt 5 vârfuri și 6 muchii. Urmează cele 6 muchii în ordinea eliminării lor. După eliminarea muchiei 1 2 graful este tot conex, deci rezultatul este 1. După eliminarea muchiei 3 4 se obțin două componente conexe, una formată din vârfurile 2, 3, iar cealaltă componentă formată din vârfurile 1, 4, 5. Restul eliminărilor nu mai trebuie explicate că ați înțeles deja.

## Cod sursă C++

```cpp
#include <bits/stdc++.h>
#define nmax 100005
#define mmax 500005
using namespace std;
int t[nmax], n, m;
pair<int, int> M[mmax];
int answer[mmax];
/// returneaza nodul radacina din componenta conexa
/// din care face parte nodul x
inline int Find(int x)
{
    int rad, y;
    rad = x;
    while (t[rad] != 0) rad = t[rad];
    while (x != rad)
    {
        y = t[x];
        t[x] = rad;
        x = y;
    }
    return rad;
}
/// unifica componentele conexe care au ca radacini
/// nodurile x si y
inline void Union(int x, int y)
{
    t[y] = x;
}
int main()
{
    int i, x, y, nrCompCon;
    cin >> n >> m;
    for (i = 1; i <= m; i++)
    {
        cin >> x >> y;
        M[i] = make_pair(x, y);
    }
    nrCompCon = n;
    for (i = m; i >= 1; i--)
    {
        answer[i] = nrCompCon;
        x = Find(M[i].first);
        y = Find(M[i].second);
        if (x != y)
        {
            Union(x, y);
            nrCompCon--;
        }
    }
    /// afisare
    for (i = 1; i <= m; i++)
        cout << answer[i] << "\n";
    return 0;
}
```

## Resurse

- [Pagina originală](https://codulluiandrei.ro/rezolvari/pbinfo/2282)
- [Sursa C++](https://codulluiandrei.ro/rezolvari/pbinfo/2282/cod.cpp)
- [Sursa pe GitHub](https://raw.githubusercontent.com/codulluiandrei/pbinfo/main/pbinfo-2282/main.cpp)
- [Cursuri de informatică pentru BAC](https://codulluiandrei.ro/academia/info-curs/pachet-cpp/)