पेड़ों की गिनती करो

Question

एक पेड़ एक जुड़ा हुआ, अप्रत्यक्ष ग्राफ है जिसमें कोई चक्र नहीं है। आपका कार्य यह गिनना है कि दी गई संख्याओं के साथ कितने अलग-अलग पेड़ हैं।

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

यह देखने के लिए कि 1 से 6 आकार के सभी अलग-अलग पेड़ किस तरह दिखते हैं, यहाँ एक नज़र डालें ।

आपके द्वारा आउटपुट की जा रही श्रृंखला OEIS में A000055 है ।

प्रतिबंध : इनपुट पर चलने के लिए आपका समाधान मिनट या उससे कम की सीमा में होना चाहिए 6। यह घातीय समय के एल्गोरिदम को खत्म करने का इरादा नहीं है, लेकिन इसका उद्देश्य दोगुना-घातीय समय के एल्गोरिदम को खत्म करना है, जैसे कि सभी किनारे सेटों के लिए मजबूर करना।

इनपुट: कोई भी गैर-नकारात्मक पूर्णांक।

इनपुट किसी भी मानक माध्यम से हो सकता है, जिसमें एसटीडीआईएन, कमांड लाइन पैरामीटर, फ़ंक्शन इनपुट आदि शामिल हैं।

आउटपुट: इनपुट के रूप में कई कोने के साथ अलग पेड़ों की संख्या।

आउटपुट किसी भी मानक साधन से हो सकता है, जिसमें STDOUT, फ़ंक्शन रिटर्न आदि शामिल हैं।

उदाहरण: 0, 1, 2, 3, 4, 5, 6, 7 लौट जाना चाहिए 1, 1, 1, 1, 2, 3, 6, 11।

स्कोरिंग: कोड गोल्फ, बाइट्स द्वारा। सबसे छोटी कोड जीत हो सकती है!

मानक खामियों से मना किया।

Answer 1

CJam (69 बाइट्स)

]qi:X,{1e|,:):N{N\f{1$%!*}W$.*:+}%1$W%.*:+N,/+}/W\+_1,*X=\_W%.*:+-Y/z

ऑनलाइन डेमो

व्याख्या

मूल विचार OEIS में वर्णित उत्पादक फ़ंक्शन को लागू करना है। इनपुट एक बुरा विशेष मामला है, लेकिन मैंने जो अंतिम ट्वीक्स तैयार किए हैं, उनका उत्पादन - 1 उस मामले के लिए किया गया है, इसलिए z (निरपेक्ष मूल्य के लिए) इसे ख़त्म करता है। यह यहाँ की अजीब चाल है।$0$$-1$$z$

.*:+तीन बार दोहराया जाता है, और ऐसा लगता है कि अगर इसे निकाला जाए तो यह बाइट को बचा सकता है {.*:+}:F~। हालांकि, यह विशेष केस टूटता है , क्योंकि यह बाहरी लूप को बिल्कुल भी निष्पादित नहीं करता है।$0$

---

हम A000081 के लिए सहायक उत्पादक फ़ंक्शन का उपयोग करते हैं , जिनकी शर्तों की पुनरावृत्ति होती है

a[0] = 0
a[1] = 1
For n >= 1, a[n+1] = (sum_{k=1}^n a[n-k+1] * sum_{d|k} d * a[d]) / n

मैं बदलना सुनिश्चित करें कि कुछ भाषाओं का निर्माण-इन हैं हूँ मॉबियस उलटा के लिए , लेकिन CJam नहीं करता है, मुझे मिला सबसे अच्छा तरीका एक सरणी मानचित्रण $\sum_{d\mid k} d \times a[d]$$d$ करने के लिए k % d == 0 ? d : 0और उसके बाद के साथ एक pointwise गुणा करना का उपयोग कर । नोट यह सुविधाजनक है कि यहाँ बनाया है करने के लिए एक सूचकांक 1 से शुरू, क्योंकि हम शून्य से बचने के विभाजन करना चाहते हैं जब वजन की स्थापना। यह भी ध्यान दें कि यदि पॉइंटवाइज ऑपरेशन को आपूर्ति की गई दो सरणियां समान लंबाई नहीं हैं, तो लंबे समय तक के मानों को छोड़ दिया जाता है: इसलिए हमें या तो पहले k की शर्तों को लेना होगा$a$.*$a$$k$ या वजन की सरणी तक जा कर एन । बाद वाला छोटा लगता है। तो यह उलटा Möbius के लिए खातों को बदलना$a$$n$N\f{1$%!*}W$.*:+

यदि हम प्रतिलोम मोबियस परिवर्तन के परिणाम को कहते हैं M, तो हमारे पास अब

$$a[n+1] = \frac{1}{n} \sum_{k=1}^n a[n-k+1] \times M[k]$$

अंशांकक स्पष्ट रूप से एक शब्द है, इसलिए हम इसे या तो या एम की एक प्रति को उल्टा करके और फिर एक बिंदुवार गुणा और योग लेते हुए संभाल सकते हैं । फिर, हमारा सूचकांक 1 से n तक भिन्न होता है$a$$M$$1$$n$ , और इसके अलावा में हम सूचकांक करने के लिए जो राशि जोड़ी करना चाहते हैं , तो यह सूचकांक करने के लिए फिर से सुविधाजनक है एक हम अब के लिए जिम्मेदार किया है 1 के बजाय 0. से$n + 1$$a$

 qi:X,{   ,:):N{N\f{1$%!*}W$.*:+}%1$W%.*:+N,/+}/

सहायक जनरेटिंग फंक्शन का बिंदु A000055 के सूत्र अनुभाग द्वारा दिया गया है:

G.f.: A(x) = 1 + T(x) - T^2(x)/2 + T(x^2)/2,
where T(x) = x + x^2 + 2*x^3 + ... is the g.f. for A000081.

के संदर्भ में , इस का मतलब है उत्पादन हम तलाश है कि [ x = 0 ] + एक [ एक्स ] + $a$

$$[x = 0] + a[x] + \frac{1}{2}\left(a[x/2] - \sum_{i=0}^n a[i] \times a[n-i]\right)$$

$a[x/2]$$x$1,*X=

0\+$a[0] = 0$$X = 0$W\+$-2a[x] + \sum_{i=0}^n a[i] \times a[n-i]$$2$$a[x]$

तो हमने समझाया है

 qi:X,{   ,:):N{N\f{1$%!*}W$.*:+}%1$W%.*:+N,/+}/W\+_1,*X=\_W%.*:+-Y/

शेष विवरण विशेष मामले से संबंधित हैं। मैंने मूल रूप से पुनरावृत्ति का सख्ती से पालन करना शुरू किया1]$N = 1$

1]qi:X,1>{ ... }/

$X = 0$$a$[-1 1]$0$$[x = 0]$X!+1e|

$a$$1$$N = 0$

]qi:X,{ ... /+}/

स्पष्ट रूप से शून्य से विभाजन देता है। लेकिन अगर हम कोशिश करें

]qi:X,{1e| ... /+}/

तब यह काम करता है। हमें मिला

             e# Stack: [] 0
1e|          e# Stack: [] 1
,:):N        e# Stack: [] [1]
{            e# We only execute this loop once
  N\f{1$%!*} e#   1 divides 1, so stack: [] [1]
  W$.*       e#   Remember: if the two arrays supplied to the pointwise operation
             e#   are not the same length then the values from the longer one are
             e#   left untouched. Stack: [] [1]
  :+         e#   Fold over a singleton. Stack: [] 1
}%           e# And that was a map, so stack: [] [1]
1$W%.*:+     e# Another [1] [] .*:+, giving the same result: 1
N,/          e# 1 / 1 = 1
+            e# And we append 1 to a giving [1]

जो हमारे लिए आवश्यक मूल्य का उत्पादन करता है।

$X = 0$$-1$[-1]$(-1 - \frac12(-1 \times -1)) = -1$$0$$1$$-1$$1$ केवल एक लेता है: zपूर्ण मूल्य देता है।

Answer 2

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

l{m`SmSSMcXdUQk2.pQusm+L,dhHGhHtQ]Y

प्रदर्शन।

इस कार्यक्रम को दो भागों में विभाजित किया जा सकता है: सबसे पहले, हम सभी संभव पेड़ उत्पन्न करते हैं, फिर हम डुप्लिकेट को हटाते हैं।

यह कोड पेड़ों को उत्पन्न करता है usm+L,dhHGhHtQ]Y:। पेड़ों को किनारों की एक संक्षिप्त सूची के रूप में दर्शाया जाता है, कुछ इस तरह से:

[0, 1, 0, 2, 2, 3, 1, 4]

प्रत्येक नंबर एक शीर्ष के लिए खड़ा है, और हर दो नंबर एक बढ़त है। यह एक किनारे पर बार-बार एक संभावित दांव जोड़कर बनाया गया है जो पहले से मौजूद है और जो नया बनाया गया है, और पिछले चरण से प्रत्येक संभव पेड़ पर इसे जोड़ रहा है। यह सभी संभव पेड़ों को उत्पन्न करता है, क्योंकि सभी पेड़ों को बार-बार एक शीर्ष और मौजूदा पेड़ से एक किनारे जोड़कर उत्पन्न किया जा सकता है। हालांकि, आइसोमॉर्फिक पेड़ बनाए जाएंगे।

अगला, प्रत्येक पेड़ के लिए, हम हर संभव रीलाबलिंग करते हैं। यह कोने के सभी संभावित क्रमांकन पर मैपिंग द्वारा किया जाता है ( m ... .pQ), और फिर उस क्रम से मानक क्रम से पेड़ को स्थानांतरित करने के साथ XdUQk। dपेड़ kहै, क्रमचय है।

फिर, हम किनारों को अलग-अलग सूचियों के साथ अलग-अलग करते हैं c ... 2, प्रत्येक किनारे के भीतर कोने को छाँटते हैं, प्रत्येक पेड़ के एक कैनोनिकल प्रतिनिधित्व के SMसाथ पेड़ के भीतर किनारों को सॉर्ट Sकरते हैं। ये दो चरण हैं कोडmSSMcXdUQk2.pQ ।

अब, हमारे पास प्रत्येक पेड़ की हर संभव रिबलिंग से बनी सूचियों की एक सूची है। हम इन सूचियों को क्रमबद्ध करते हैं S। किसी भी दो आइसोमॉर्फिक पेड़ों को पेड़ों के समूह में स्थानांतरित करने में सक्षम होना चाहिए। इस तथ्य का उपयोग करते हुए, हम प्रत्येक सूची को स्ट्रिंग के साथ परिवर्तित करते हैं `, फिर उन सूचियों के सेट को बनाते हैं {, और इसकी लंबाई के साथ आउटपुट करते हैं l।