एल्गोरिथ्म कि से सरल रास्तों की संख्या पाता

Question

Can किसी को भी मुझे एक रेखीय समय एल्गोरिथ्म है कि इनपुट के रूप में लेता है सुझाव है कि एक अचक्रीय निर्देशित ग्राफ और दो कोने रों और टी और रिटर्न से सरल रास्तों की संख्या रों को टी में जी । मैं एक एल्गोरिथ्म है, जिसमें मैं एक डीएफएस (गहराई पहले खोज) चलेंगे है, लेकिन अगर डीएफएस पाता टी तो यह नोड्स जो रास्ते में आता है में से किसी का (ग्रे सफेद से) रंग नहीं बदलेगा रों ⇝ $G=(V,E)$$s$$t$$s$$t$$G$
$t$$s \rightsquigarrow t$ताकि यदि यह किसी अन्य पथ का उपपथ है तो DFS भी फिर से इस उपपथ से गुजरता है। उदाहरण के लिए आसन्न सूची पर विचार करें जहां हमें से v तक के पथों की संख्या ज्ञात करने की आवश्यकता है । पी ओ एस जेड ओ आर एस वी एस आर आर वाई वाई वी वी डब्ल्यू $p$$v$
यहाँ डीएफएस के साथ शुरू होगापीऔर फिर कहते हैं कि यह करने के लिए चला जाता है की सुविधा देता हैपी⇝zdoesnot मुठभेड़ के बाद सेवीडीएफएस चलाने normally.Now दूसरा रास्ता है जाएगापीएसआरवाईवीके बाद से यह मुठभेड़vहम के कोने रंग नहीं बदलेगारों,r,y,vसे grey.Then पथpov,क्योंकिvकारंगअभी भी सफेद है। तब पथposryv,s केरंग के बाद से

$$\begin{array}{|c|c c c|} \hline p &o &s &z \\ \hline o &r &s &v\\ \hline s &r \\ \hline r &y \\ \hline y &v \\ \hline v &w \\ \hline z & \\ \hline w &z \\ \hline \end{array}$$ $p$$p \rightsquigarrow z$$v$$psryv$$v$$s,r,y,v$$pov$$v$$posryv$$s$सफेद और इसी तरह से पथ इसके अलावा एक काउंटर बनाए रखा जाता है जो v के सामने आने पर बढ़ जाता है।$poryv$$v$

क्या मेरा एल्गोरिथ्म सही है? यदि नहीं, तो इसे सही करने के लिए किन संशोधनों की आवश्यकता है या किसी अन्य दृष्टिकोण की बहुत सराहना की जाएगी।

नोट : यहां मैंने डीएफएस एल्गोरिदम पर विचार किया है जो कि "कॉर्मेन द्वारा एल्गोरिदम का परिचय" पुस्तक में दिया गया है जिसमें यह अपनी स्थिति के अनुसार नोड्स को रंग देता है। यदि नोड गैरविभाजित, अस्पष्टीकृत और पता लगाया जाता है तो रंग सफेद होगा, क्रमशः ग्रे और काले। अन्य चीजें मानक हैं।

Comments

संबंधित प्रश्न।

— राफेल

ध्यान दें कि एक निर्देशित चक्रीय ग्राफ में सभी पथ आवश्यक रूप से सरल हैं (तीक्ष्णता के आधार पर)।

— नोल्डोरिन

Answer 1

Your current implementation will compute the correct number of paths in a DAG. However, by not marking paths it will take exponential time. For example, in the illustration below, each stage of the DAG increases the total number of paths by a multiple of 3. This exponential growth can be handled with dynamic programming.

Computing the number of $s$-$t$ paths in a DAG is given by the recurrence,

$$\text{Paths}(u) = \begin{cases} 1 & \text{if } u = t \\ \sum_{(u,v) \in E} \text{Paths}(v) & \text{otherwise.}\\ \end{cases}$$

A simple modification of DFS will compute this given as

def dfs(u, t):
    if u == t:
        return 1
    else:
        if not u.npaths:
            # assume sum returns 0 if u has no children
            u.npaths = sum(dfs(c, t) for c in u.children)
        return u.npaths

It is not difficult to see that each edge is looked at only once, hence a runtime of $O(V + E)$.

Comments

I understood your algorithm and it can be made little more efficient by using dynamic programming since same recursive calls are called many times so its better to save.Right??

— सौरभ

@SaurabhHota, it is using dynamic programming. The first time the vertex $u$ is encountered, it computes the number of paths it has to $t$. This is stored in u.npaths. Each subsequent call to $u$ will not recompute its number of paths, but simply return u.npaths.

— Nicholas Mancuso

For such graphs, isn't the answer just m^n where m is the number of nodes in a column (3 here) and n is the number of columns excluding s,t (4 here). output is 3^4 = 81 for the example graph.

— saadtaame

@saadtaame, sure; however, my intent was to merely showcase exponential increase as the "length" of a graph grows. Of course for that highly structured graph you can count in closed form while the algorithm listed works for all graphs.

— Nicholas Mancuso

The $O(V+E)$ running time assumes that you can perform the necessary additions in constant time, but the numbers being added can have $\Theta(V)$ bits in the worst case. If you want the exact number of paths, the running time (counting bit operations) is actually $O(VE)$.

— JeffE

Answer 2

You only need to notice that the number of paths from one node to the target node is the sum of the number of paths from its children to the target. You know that this algorithm will always stop because your graph doesn't have any cycles.

Now, if you save the number of paths from one node to the target as you visit the nodes, the time complexity becomes linear in the number of vertices and memory linear in the number of nodes.

Answer 3

The number of paths between any two vertices in a DAG can be found using adjacency matrix representation.

Suppose A is the adjacency matrix of G. Taking Kth power of A after adding identity matrix to it, gives the number of paths of length <=K.

Since the max length of any simple path in a DAG is |V|-1, calculating |V|-1 th power would give number of paths between all pairs of vertices.

Calculating |V|-1 th power can be done by doing log(|V|-1) muliplications each of TC: |V|^2.

Comments

The question asks for a linear time algorithm. Your algorithm is slower than that.

— D.W.

@Vivek can you mention a reference for the theorems in your answer?

— Hamideh