Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

ग्राफ में BFS का उपयोग करके एक नोड से पहुंच योग्य सभी नोड्स खोजने का पायथन प्रोग्राम


जब ट्री के सभी नोड्स का योग खोजना हो, तो एक क्लास बनाई जाती है जिसमें रूट नोड सेट करने, ट्री में एलिमेंट्स जोड़ने, विशिष्ट एलिमेंट खोजने और ट्री के एलिमेंट्स को जोड़कर योग खोजने आदि के लिए मेथड्स होते हैं। क्लास का एक इंस्टेंस बनाकर इन मेथड्स को एक्सेस और उपयोग किया जा सकता है।

उदाहरण

from collections import deque

def add_edge(v, w):
    global visited_node, adj
    adj[v].append(w)
    adj[w].append(v)

def BFS_operation(component_num, src):
    global visited_node, adj
    queue = deque()
    queue.append(src)
    visited_node[src] = 1
    reachableNodes = []
    while (len(queue) > 0):
        u = queue.popleft()
        reachableNodes.append(u)
        for itr in adj[u]:
            if (visited_node[itr] == 0):
                visited_node[itr] = 1
                queue.append(itr)
    return reachableNodes

def displayReachableNodes(m):
    for i in m:
        print(i, end=" ")
    print()

def findReachableNodes(my_list, n):
    global V, adj, visited_node
    a = []
    component_num = 0
    for i in range(n):
        u = my_list[i]
        if (visited_node[u] == 0):
            component_num += 1
            a = BFS_operation(component_num, u)
        print("पहुंच योग्य नोड्स", u, "से हैं")
        displayReachableNodes(a)

V = 7
adj = [[] for i in range(V + 1)]
visited_node = [0 for i in range(V + 1)]
add_edge(1, 2)
add_edge(2, 3)
add_edge(3, 4)
add_edge(3, 1)
add_edge(5, 6)
add_edge(5, 7)
my_list = [2, 4, 5, 7]
arr_len = len(my_list)
findReachableNodes(my_list, arr_len)

आउटपुट

पहुंच योग्य नोड्स 2 से हैं 2 1 3 4
पहुंच योग्य नोड्स 4 से हैं 2 1 3 4
पहुंच योग्य नोड्स 5 से हैं 5 6 7
पहुंच योग्य नोड्स 7 से हैं 5 6 7

व्याख्या

  • आवश्यक पैकेज आयात किए जाते हैं।

  • 'add_edge' नामक एक मेथड परिभाषित की जाती है जो ट्री में एलिमेंट्स जोड़ने में मदद करती है।

  • 'BFS_operation' मेथड ब्रेडथ फर्स्ट सर्च दृष्टिकोण का उपयोग करके ट्री को ट्रैवर्स करने में मदद करती है।

  • 'displayReachableNodes' नामक एक मेथड परिभाषित की जाती है जो किसी विशिष्ट नोड से पहुंच योग्य नोड्स को प्रदर्शित करने में मदद करती है।

  • 'findReachableNodes' नामक एक मेथड परिभाषित की जाती है जो नोड्स के माध्यम से पुनरावृति करती है और एलिमेंट्स पर 'BFS_operation' करती है।

  • 'add_edge' मेथड्स ग्राफ में नोड्स जोड़ते हैं।

  • एक सूची परिभाषित की जाती है और कंसोल पर प्रदर्शित की जाती है।

  • मेथड को कॉल किया जाता है और आउटपुट कंसोल पर प्रदर्शित होता है।


  1. Python से DAG में सभी नोड्स तक पहुंचने के लिए मिनिमम वर्टेक्स कैसे ढूंढें? Python से DAG में सभी नोड्स तक पहुंचने के लिए मिनिमम वर्टेक्स कैसे ढूंढें?

    डायरेक्टेड एसाइक्लिक ग्राफ (DAG) में जिन वर्टेक्सेज़ का इन-डिग्री 0 है, उनसे सभी नोड्स पहुंचे जा सकते हैं। एल्गोरिदम सभी नोड्स का सेट बनाएं (0 से n-1)। सभी एजेज़ के डेस्टिनेशन नोड्स (v) का सेट बनाएं। सोर्स नोड्स = सभी नोड्स - डेस्टिनेशन नोड्स (यानी इन-डिग्री 0 वाले)। यही मिनिमम वर्टेक्स सेट है। उद

  1. Python से बाइनरी ट्री में गुड लीफ नोड पेयर्स की संख्या कैसे ढूंढें? Python से बाइनरी ट्री में गुड लीफ नोड पेयर्स की संख्या कैसे ढूंढें?

    दो लीफ नोड्स का पेयर गुड है अगर उनके बीच का सबसे छोटा पथ ≤ d है। पोस्ट-ऑर्डर DFS से सभी गुड पेयर्स काउंट करें। एल्गोरिदम रिकर्सिव util(root) रिटर्न करता है: प्रत्येक लीफ के लिए [depth_from_root, 0] (दूसरा मान अपडेट होता है)। लेफ्ट और राइट सबट्री के लीफ्स के लिए: डेप्थ्स इन्क्रीमेंट करें। सभी लेफ्ट-

  1. Python से सबट्री में समान लेबल वाले नोड्स की संख्या कैसे ढूंढें? Python से सबट्री में समान लेबल वाले नोड्स की संख्या कैसे ढूंढें?

    रूटेड ट्री में प्रत्येक नोड के लिए, उसके सबट्री में उसी लेबल वाले नोड्स की संख्या ढूंढें (लेबल्स लोअरकेस लेटर्स)। एल्गोरिदम एज लिस्ट से ग्राफ बनाएं (अनडायरेक्टेड)। लेबल मैप बनाएं। रिकर्सिव DFS r(ni): चिल्ड्रन के काउंटर्स मर्ज करें, अपना लेबल जोड़ें, R[ni] = count[label]। पैरेंट लिंक हटाकर साइकिल अव