C प्रोग्राम में 1 से शुरू होने वाले ग्राफ का लेक्सिकोग्राफिकली सबसे छोटा BFS प्रिंट करें

समस्या विवरण

हमें N शीर्ष और M किनारों वाला एक जुड़ा हुआ ग्राफ दिया जाएगा। हमें 1 से शुरू होने वाले ग्राफ का लेक्सिकोग्राफिकली सबसे छोटा BFS प्रिंट करना है।

लेक्सिकोग्राफिकली का अर्थ है दिए गए बिंदु से क्रम में अंतिम बिंदु मिलने तक।

उदाहरण

इनपुट: N = 5, M = 5
किनारे: (1,4), (3,4), (5,4), (3,2), (1,5)
आउटपुट: 1 4 3 2 5

सामान्य BFS ट्रैवर्सल के बजाय, हम प्रायोरिटी क्यू (मिन हीप) का उपयोग कर सकते हैं। जब भी कोई नोड विजिट किया जाता है, उसके आसन्न नोड्स को प्रायोरिटी क्यू में जोड़ें। हर बार, हम एक नया नोड विजिट करते हैं, यह प्रायोरिटी क्यू में सबसे छोटे इंडेक्स वाला होगा। नोड्स को प्रिंट करें जब भी हम उन्हें विजिट करते हैं, 1 से शुरू करके।

एल्गोरिदम

शुरुआत
चरण 1: void lexo(vector array[], int n) फंक्शन घोषित करें
    bool arr[n + 1] घोषित करें
    memset(arr, 0, sizeof arr) कॉल करें
    STL priority_queue, greater> que उपयोग करें
    arr[1] = true सेट करें
    que.push(1) कॉल करें
    जब तक !que.empty() लूप
        int now = que.top() घोषित करें
        que.pop() कॉल करें
        now प्रिंट करें
        (auto p : array[now]) के लिए लूप
            यदि !arr[p] तो
                que.push(p) कॉल करें
                arr[p] = true कॉल करें
            अंत
        अंत
    अंत
चरण 2: void edge(int i, int j, vector ar[]) फंक्शन घोषित करें
    ar[i].push_back(j) कॉल करें
    ar[j].push_back(i) कॉल करें
चरण 3: main() में
    n = 5, m = 5 घोषित करें
    STL vector arr[n + 1] उपयोग करें
    edges(1,4, arr) कॉल करें
    edges(3,4, arr) कॉल करें
    lexo(arr, n) कॉल करें
रोकें

C++ प्रोग्राम उदाहरण

#include <bits/stdc++.h>
using namespace std;

void lexo(vector array[], int n){
    bool arr[n + 1];
    memset(arr, 0, sizeof arr);
    priority_queue, greater> que;
    arr[1] = true;
    que.push(1);
    while (!que.empty()){
        int now = que.top();
        que.pop();
        cout << now << " ";
        for (auto p : array[now]){
            if (!arr[p]){
                que.push(p);
                arr[p] = true;
            }
        }
    }
}

void edge(int i, int j, vector ar[]){
    ar[i].push_back(j);
    ar[j].push_back(i);
}

int main(){
    int n = 5, m = 5;
    vector arr[n + 1];
    edges(1,4, arr);
    edges(3,4, arr);
    edges(5,4, arr);
    edges(3,2, arr);
    edges(1,5, arr);
    lexo(arr, n);
    return 0;
}

आउटपुट

उपरोक्त प्रोग्राम चलाने पर निम्नलिखित आउटपुट उत्पन्न होगा:

1 4 3 2 5