सामयिक प्रकार की कुल संख्या

Question

किसी दिए गए DAG (निर्देशित एसाइक्लिक ग्राफ) के लिए, इसका प्रत्येक टोपोलॉजिकल प्रकार सभी लंबों का क्रमपरिवर्तन है, जहां DAG में प्रत्येक किनारे (u, v) के लिए, u क्रमचय में v से पहले प्रकट होता है ।

आपका कार्य किसी दिए गए DAG के सामयिक प्रकारों की कुल संख्या की गणना करना है।

नियम

• आप ग्राफ को दर्शाने के लिए किसी भी प्रारूप का उपयोग कर सकते हैं, जैसे कि आसन्न मैट्रिक्स, आसन्न सूची या किनारे की सूची, जब तक आप अपने एन्कोडिंग में उपयोगी गणना नहीं करते हैं। यदि आप उपयोगी हैं, तो आपके पास इनपुट में वर्टेक्स काउंट या वर्टेक्स सूची जैसी चीजें भी हो सकती हैं।
• आप मान सकते हैं कि इनपुट में ग्राफ हमेशा एक डीएजी है (कोई चक्र नहीं है)।
• आपके कार्यक्रम को किसी भी इनपुट के लिए सिद्धांत रूप में काम करना चाहिए। लेकिन यह विफल हो सकता है अगर यह आपकी भाषा में मूल पूर्णांक प्रकार को ओवरफ्लो करता है।
• किसी भी प्रकार में शीर्षकों के नाम लगातार मान हो सकते हैं। उदाहरण के लिए: 0 या 1. से शुरू होने वाली संख्या (और केवल यदि आप इस संख्या में कोड को स्टोर नहीं कर रहे हैं, तो निश्चित रूप से।)
• यह कोड-गोल्फ है। सबसे छोटा कोड जीतता है।

उदाहरण

विभिन्न स्वरूपों में यह एक ही इनपुट है। आपके कार्यक्रम को उन सभी को स्वीकार नहीं करना है। ऊर्ध्वाधर हमेशा पूर्णांक 0 पर शुरू होते हैं।

Adjacency list:
[ [1 2 3 5] [2 4] [] [2] [] [3] ]
Adjacency matrix:
[ [0 1 1 1 0 1] [0 0 1 0 1 0] [0 0 0 0 0 0] [0 0 1 0 0 0] [0 0 0 0 0 0] [0 0 0 1 0 0] ]
Edge list:
6 [ [0 1] [0 2] [0 3] [0 5] [1 2] [1 4] [3 2] [5 3] ]

यह इस चित्र में दिखाया गया ग्राफ है:

आउटपुट होना चाहिए:

9

टोपोलॉजिकल प्रकार हैं:

[0 1 4 5 3 2]
[0 1 5 4 3 2]
[0 1 5 3 4 2]
[0 1 5 3 2 4]
[0 5 1 4 3 2]
[0 5 1 3 4 2]
[0 5 1 3 2 4]
[0 5 3 1 4 2]
[0 5 3 1 2 4]

Comments

समारोह? पूरे कार्यक्रम? या तो?

— isaacg

@ आइसाकग या तो।

— jimmy23013

Answer 1

सीजाम - २५

q~{_f{1$-_j@j@&!*}_!+:+}j

User23013 से बहुत मदद के साथ :)

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

सामान्य एल्गोरिथ्म xnor के पायथन समाधान के समान है ।
यहां कुंजी jऑपरेटर है, जो पुनरावृत्ति को याद करती है। यह प्रारंभिक मान (ओं) (जैसा कि f (0), f (1), आदि) और पुनरावर्तन को परिभाषित करने के लिए एक ब्लॉक के लिए एक पैरामीटर, एक मान या सरणी लेता है। jऑपरेटर एक ही ब्लॉक करने के लिए पुनरावर्ती (और memoized) कॉल करने के लिए ब्लॉक के अंदर फिर से प्रयोग किया जाता है। इसका उपयोग कई मापदंडों के साथ भी किया जा सकता है, लेकिन यहां ऐसा नहीं है।
user23013 का महान नवाचार विभिन्न डेटा प्रकारों के साथ j का उपयोग करना है, जिससे आसन्न सूची का उपयोग प्रारंभिक मानों के सरणी के रूप में किया जाता है।

q~             read and evaluate the input (vertex list followed by adjacency list)
{…}j           run the block on the vertex list, doing memoized recursion
                and using the adjacency list for initial values
    _          copy the vertex list
    f{…}       for each vertex and the vertex list
        1$-    copy the vertex and remove it from the list
                Python: "V-{v}"
        _j     copy the reduced list and call the j block recursively
                this solves the problem for the reduced vertex list
                Python: "f(G,V-{v})"
        @j     bring the vertex to the top of the stack and call the j block recursively
                in this case, it's called with a vertex rather than a list
                and the memoized value is instantly found in the list of initial values
                effectively, this gets the list of vertices adjacent to the current vertex
                Python: "G[v]"
        @&     bring the reduced list to the top of the stack and intersect
        !*     multiply the number of topological sorts of the reduced vertex list
                with 1 if the intersection was empty and 0 if not
                Python: equivalent to "*(V-G[v]==V)"
               after this loop we get an array of sub-results for the reduced vertex lists
    _!+        add 1 or 0 to the array if the array was empty or not
                because we want to get 1 for the empty array
                Python: equivalent to "V<{0}or"
    :+         add the numbers in the array
                Python: "sum(…)"

Comments

इनपुट में वर्टेक्स सूची को स्पष्ट रूप से अनुमति देने के लिए संपादित। अब 25 बाइट्स ।

— jimmy23013

@ user23013 यह किस तरह का जादू है? : o

— aditsu छोड़ दिया क्योंकि SE ईवीआईएल

Answer 2

पायथन, 58

f=lambda G,V:V<{0}or sum(f(G,V-{v})*(V-G[v]==V)for v in V)

इनपुट में एक आसन्न शब्दकोश Gऔर एक शीर्ष सेट होता है V।

G = {0:{1,2,3,5}, 1:{2,4}, 2:set(), 3:{2}, 4:set(), 5:{3}, 6:set()}
V = {0,1,2,3,4,5}

कोड पुनरावर्ती है। सेट Vसभी नोड्स को संग्रहीत करता है जो अभी भी विज़िट करने की आवश्यकता है। प्रत्येक संभावित अगले नोड के लिए, हम अगर कोई शेष कोने के साथ, यह को इंगित देखकर इसकी उपयुक्तता की जांच V-G[v]==Vजांच करते हुए कि Vऔर G[v]संबंध तोड़ना है। ऐसे सभी उपयुक्त शीर्षों के लिए, हम इसे हटाए गए के साथ सामयिक प्रकारों की संख्या जोड़ते हैं। आधार मामले के रूप में, खाली सेट 1 देता है।

Comments

बढ़त सूची का उपयोग नहीं करने के लिए +1।

— jimmy23013

Answer 3

मैथेमेटिका, 80 57 51 बाइट्स

Count[Permutations@#,l_/;l~Subsets~{2}~SubsetQ~#2]&

परिभाषा का बहुत सीधा-सीधा कार्यान्वयन। मैं केवल सभी क्रमपरिवर्तन कर रहा हूं और गिनता हूं कि उनमें से कितने वैध हैं। यह जांचने के लिए कि क्या एक क्रमपरिवर्तन वैध है, मुझे क्रमपरिवर्तन में सभी जोड़े जोड़े मिलते हैं। आसानी से, Subsets[l,{2}]न केवल मुझे सभी जोड़े प्रदान करते हैं, यह उस क्रम को भी बनाए रखता है जो वे पाए जाते हैं l- बस मुझे जो चाहिए।

ऊपर एक फ़ंक्शन है जो शीर्ष सूची और किनारे की सूची की अपेक्षा करता है, जैसे

f[{1, 2, 3, 4, 5, 6}, {{1, 2}, {1, 3}, {1, 4}, {1, 6}, {2, 3}, {2, 5}, {4, 3}, {6, 4}}]

यदि आप फ़ंक्शन को कॉल करते हैं f।

मैं इसे गोल्फ करने की कोशिश करूंगा, या हो सकता है कि बाद में एक और दृष्टिकोण का उपयोग करूं।

Answer 4

पायथ, 27 बाइट्स

Mlf!sm}_dHfq2lYyTfqSZUZ^UGG

एक 2 इनपुट समारोह को परिभाषित करता है, g। पहला इनपुट कोने की संख्या है, दूसरा निर्देशित किनारों की सूची है।

परीक्षा करना:

Code:
Mlf!sm}_dHfq2lYyTfqSZUZ^UGGghQeQ

Input:
6, [ [0, 1], [0, 2], [0, 3], [0, 5], [1, 2], [1, 4], [3, 2], [5, 3] ]

इसे यहाँ आज़माएँ।

Comments

@ user23013 बोहट गिनती और सूची का उपयोग अभिव्यक्ति में किया जा रहा है ^UGG, जो सभी Gप्रविष्टि सूचियों को उत्पन्न करता है range(len(G))।

— isaacg

मेरा मतलब है, क्या यह छोटा होगा यदि आप [0, 1, ...]सीधे इनपुट में उपयोग करते हैं?

— jimmy23013

@ user23013 नहीं, यह समान लंबाई होगी: ^GlGबनाम ^UGG।

— isaacg

Answer 5

हास्केल, 102 107 100 89 85 बाइट्स

import Data.List
(%)=elemIndex
n#l=sum[1|p<-permutations[0..n],and[u%p<v%p|[u,v]<-l]]

इनपुट उच्चतम शीर्ष संख्या (0 से शुरू) और एक एज लिस्ट है, जहां एक एज दो एलिमेंट लिस्ट है। उपयोग उदाहरण:5 # [[0,1], [0,2], [0,3], [0,5], [1,2], [1,4], [3,2], [5,3]]

यह कैसे काम करता: सभी क्रमपरिवर्तन गिनती pकोने जिसके लिए सभी किनारों के [u,v]संतुष्ट: की स्थिति uमें pकम है की स्थिति की तुलना में vमें p। यह परिभाषा का सीधा कार्यान्वयन है।

संपादित करें: मेरा पहला संस्करण टोपोलॉजिकल प्रकारों को स्वयं लौटाता है और न कि कितने हैं। ठीक कर दिया।

एडिट II: कनेक्टेड वर्टिकल के साथ ग्राफ़ के लिए काम नहीं किया। ठीक कर दिया।

Comments

मैं केवल कोने नहीं बल्कि किनारों के साथ एक टेस्ट केस जोड़ने की सोच रहा हूं ...

— jimmy23013

@ user23013: ग्राफ से जुड़े कामों के लिए, जो अभी नहीं जुड़े हैं। यह भी छोटा हो गया।

— nimi