BFS – Parcurgerea in latime

By Matraguna Mihai Last updated mart. 10, 2018

 0

 Share

Prin parcurgerea grafului G se întelege vizitarea, tuturor nodurilor, plecând de la un

nod de plecare, vizitand in mod progresiv fiecare nod al grafului. Probabil ati auzit pana
acum de DFS sau BFS

Un graf poate fi parcurs în următoarele două moduri:

 în adâncime (DFS = Depth First Search)
 în lătime (BFS = Breadth First Search)

Am prezentat deja parcurgerea in adancime, asa ca astazi o sa discutam despre

parcurgerea in latime (BFS).

Memorarea vecinilor
Vom folosii libraria #include <vector> pentru a utiliza vectori alocati dinamic.
Explicatia o gasiti in articol.

1 #include <vector>
2 const int NLIM = 100005;
3 vector < int > Edge[NLIM];

De data aceasta vom avea de a face cu un graf orientat (problema BFS – infoarena.ro)

asa ca vom stoca doar un singur sens. Avem grija desigur sa citim bine fisierul de
intrare.

1 Edge[x].push_back(y);

Folosirea cozii
Deoarece algoritmul BFS parcurge mai intai toate nodurile de acelasi nivel (adica „toti
vecinii deodata”), avem nevoie sa folosim o coada pentru a retine nodurile ce urmeaza a
fi parcurse.

1 #include    <queue>
2 queue <int> Coada;
3 Coada.push(NodStart);

Algoritmul BFS
Declaram vectorul global „Distanta” in care Distanta[i] va reprezenta distanta de la
nodul de start la nodul numarul i.

1 void BFS()
2 {
3     int Nod, Vecin;
4     while(!Coada.empty())
5     {
6         Nod =  Coada.front();
7         Coada.pop();
8         for(unsigned int i = 0; i < Edge[Nod].size(); i++)
9         {
10             Vecin = Edge[Nod][i];
11             if(Distanta[Vecin] == -1)
12             {
13                 Coada.push(Vecin);
14                 Distanta[Vecin] = Distanta[Nod] + 1;
15             }
16         }
17     }
18 }

Primul lucru in algloritmul BFS va fi intotdeauna sa luam primul nod din coada si sa-l
analizam. Functia front() preia primul element din coada, in timp ce functia pop il
sterge din coada. Mai multe detalii despre clasa <queue>, gasiti aici: Coada C++.

Dupa ce am preluat nodul curent din coada, ii punem toti vecinii in coada si le calculam
distanta.

La final dupa ce am parcurs toate nodurile, afisam distanta pentru fiecare nod in parte.
1 for(int i = 1; i <= N; i++)
2     fout << Distance[i] << " ";

Tot algoritmul pentru obtinerea celor 100 de puncte pe infoarena.ro poate fi gasit mai
jos:

1 #include    <iostream>
2 #include    <fstream>
3 #include    <vector>
4 #include    <queue>
5  
6 using namespace std;
7  
8 ifstream fin("bfs.in");
9 ofstream fout("bfs.out");
10  
11 const int NLIM = 100005;
12  
13 int N, M, S;
14 int Distance[NLIM];
15  
16 vector <int> Edge[NLIM];
17 queue <int> Q;
18  
19 void BFS()
20 {
21     int Node, Next;
22     while(!Q.empty())
23     {
24         Node =  Q.front();
25         Q.pop();
26         for(unsigned int i = 0; i < Edge[Node].size(); i++)
27         {
28             Next = Edge[Node][i];
29             if(Distance[Next] == -1)
30             {
31                 Q.push(Next);
32                 Distance[Next] = Distance[Node] + 1;
33             }
34         }
35     }
36 }
37  
38 void Read()
39 {
40     fin >> N >> M >> S;
41     for(int i = 1; i <= M; i++)
42     {
43         int x, y;
44         fin >> x >> y;
45         Edge[x].push_back(y);
46     }
47     for(int i = 1; i <= N; i++)
48         Distance[i] = -1;
49     Distance[S] = 0;
50  
51     Q.push(S);
52  
53     BFS();
54  
55     for(int i = 1; i <= N; i++)
56         fout << Distance[i] << " ";
57 }
58  
59 int main()
60 {
61     Read();
62     return 0;
63 }