Carian luas pertama tidak menggunakan baris gilir

Breadth First, Look (BFS) ialah pengiraan lintasan graf yang digunakan untuk mengkaji pusat dalam gerakan keluasan dalam graf. Penggunaan biasa BFS menggunakan struktur maklumat talian untuk menjejaki hab masuk. Walau apa pun, ia boleh difikirkan untuk memanfaatkan struktur maklumat lain untuk melaksanakan BFS tanpa menggunakan wayar eksplisit.

Satu cara alternatif untuk melaksanakan BFS tanpa wayar adalah dengan menggunakan dua kluster atau rekod: satu untuk hab pada tahap semasa yang sedang disiasat, dan satu untuk hab peringkat seterusnya untuk disiasat. Pada mulanya, senarai peringkat semasa mengandungi pusat sumber.

Pengiraan menyerlahkan senarai tahap semasa dahulu dan pergi ke setiap hab. Bagi setiap hab yang dilalui, hab bersebelahannya diperiksa. Jika hab bersebelahan tidak dilawati, ia ditandakan sebagai dilawati dan ditambah ke senarai peringkat lain. Pemegang akan diteruskan sehingga semua hab dalam senarai tahap semasa telah diluluskan.

Setelah senarai tahap semasa dilalui sepenuhnya, pengiraan diteruskan ke senarai tahap lain dan cincang semula jalan ke hab dan mengakses senarai tahap seterusnya. Penyediaan ini berterusan sehingga tiada lagi nod yang tidak dilawati.

Kaedah penggunaan

Pendekatan mengutamakan keluasan

Pendekatan mengutamakan keluasan

Algoritma BFS bermula dari hab sumber, menyiasat jirannya dan terkini berpindah ke peringkat jiran yang lain. Gunakan struktur maklumat talian untuk menjejaki hab yang anda lawati. Dalam setiap kitaran, pengiraan melawat hab, menandakannya sebagai selesai, dan beratur hab bersebelahan yang belum dilawati. Persediaan ini akan diteruskan sehingga semua pusat yang boleh diakses telah dilawati.

Kod ini memulakan pelaras vektor untuk mewakili senarai carta yang menular. Setiap fail vektor dibandingkan dengan pusat, dan setiap nilai yang direkodkan mengandungi pusat bersebelahan. Traversal BFS dilakukan oleh tugas BFS, yang mengambil hab sumber, bilangan hab N, vektor yang melalui hab, dp berasingan dan vektor v yang digunakan untuk menjejaki hab yang akan dilawati. Tugas bfsTraversal memulakan hab yang hilang dan memadamkan vektor, kemudian memanggil tugas BFS untuk melaksanakan traversal.

Algoritma

• Buat perwakilan senarai jangkitan graf.

• Memulakan talian untuk menyimpan hab untuk diakses.

• Mulakan kluster yang hilang untuk menjejaki nod yang hilang.

• Mulakan kelompok pemadaman untuk menyimpan kandungan yang dipadamkan daripada hab sumber pada setiap hab. Tetapkan pembatas hab sumber kepada 0.

• Atur barisan hab sumber dan semak sama ada ia telah diakses.

• Walaupun saluran paip tidak boleh disucikan, sila lakukan perkara berikut:

• Padamkan hab di kepala barisan. Bagi setiap hab jiran yang telah dinyah gilir dan belum dilalui, lakukan perkara berikut: Baris gilir hab jiran. Tandai hab bersebelahan sebagai dilawati. Pemadaman hab jiran dikemas kini untuk menghentikan pemadaman hab (juga 1).

• Ulang langkah 6 sehingga baris kosong.

• Selepas traversal BFS selesai, gugusan berasingan akan mengandungi selang dari nod sumber ke semua pusat lain dalam graf.

• (Pilihan) Anda juga boleh menjejaki setiap hab induk hab dalam traversal BFS untuk pergi dari hab sumber ke semua hab lain dengan cara yang paling mudah.

Contoh

#include <iostream>
#include <queue>
#include <unordered_set>
using namespace std;

void bfsTraversal(int adjacencyList[][2], int numVertices, int source) {
   bool visited[numVertices + 1] = {false};
   int distances[numVertices + 1] = {0};

   queue<int> vertices;
   vertices.push(source);
   visited[source] = true;

   while (!vertices.empty()) {
      int node = vertices.front();
      cout << node << ", ";
      vertices.pop();

      for (int i = 0; i < 2; i++) {
         int next = adjacencyList[node][i];
            
         if (!visited[next]) {
            vertices.push(next);
            distances[next] = distances[node] + 1;
            visited[next] = true;
         }
      }
   }
}

int main() {
    int adjacencyList[][2] = {{0, 0}, {1, 2}, {3, 4}, {0, 0}, {0, 0}};
    int numVertices = 4;
    int source = 2;

    bfsTraversal(adjacencyList, numVertices, source);

    return 0;
}

Output

2,3,4,0

Contoh

#include <iostream>
#include <vector>
using namespace std;

void bfsTraversal(vector<vector<int>>& adjacencyList, int N, int source) {
    vector<bool> visited(N + 1, false);
    vector<int> distances(N + 1, 0);
    vector<int> vertices;

    vertices.push_back(source);
    visited[source] = true;

    int curr = 0;
    while (curr < vertices.size()) {
        int node = vertices[curr];
        cout << node << ", ";

        for (int i = 0; i < adjacencyList[node].size(); i++) {
            int next = adjacencyList[node][i];

            if (!visited[next]) {
                vertices.push_back(next);
                distances[next] = distances[node] + 1;
                visited[next] = true;
            }
        }

        curr++;
    }

    cout << "\nDistances from source " << source << ":\n";
    for (int i = 1; i <= N; i++) {
        cout << "Node " << i << ": " << distances[i] << endl;
    }
}

int main() {
    int N = 8;
    vector<vector<int>> adjacencyList(N + 1);
    adjacencyList[0] = {1, 2};
    adjacencyList[1] = {2};
    adjacencyList[2] = {0, 3};
    adjacencyList[3] = {3};
    adjacencyList[4] = {5};
    adjacencyList[5] = {6, 7};
    adjacencyList[6] = {};
    adjacencyList[7] = {};
    adjacencyList[8] = {};

    int source = 5;

    bfsTraversal(adjacencyList, N, source);

    return 0;
}

Output

5, 6, 7, 
Distances from source 5:
Node 1: 0
Node 2: 0
Node 3: 0
Node 4: 0
Node 5: 0
Node 6: 1
Node 7: 1
Node 8: 0

Kesimpulan

Artikel ini menerangkan pengiraan carian pertama luas (BFS) tanpa menggunakan struktur maklumat baris. Pengiraan BFS biasanya digunakan untuk menavigasi carta mengikut cara langkah demi langkah bermula dari pusat sumber tertentu. Biasanya, laluan digunakan untuk menyimpan hab untuk dilalui. Walau apa pun, artikel ini mengkaji pendekatan alternatif yang menggunakan senarai asas atau pengelompokan untuk menyimpan tahap hab seterusnya.

Penggunaan terpilih ini melengkapkan kajian graf yang luas-pertama. Artikel ini mengesan langkah-langkah pengiraan BFS, seperti memulakan rekod berjangkit, mengekalkan gugusan pergi-to dan pemisahan, dan menggunakan bulatan untuk menekankan peringkat pusat. Ia juga menyediakan arahan kod C yang menggambarkan traversal BFS tanpa menggunakan satu baris. Kod mengkaji graf dengan tepat, mencetak pilih atur traversal BFS dan mengira jarak dari hab sumber ke semua nod lain. Secara keseluruhannya, artikel ini memberikan penjelasan yang jelas dan penggunaan pengiraan BFS yang boleh dilaksanakan tanpa menggunakan garisan, menunjukkan pendekatan alternatif untuk menavigasi graf dengan cara yang luas dahulu.

Atas ialah kandungan terperinci Carian luas pertama tidak menggunakan baris gilir. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!