Nxnxn घन जाली में m अंक के सभी सेट उत्पन्न करने के लिए एल्गोरिथम जो समरूपता के तहत अद्वितीय हैं

Question

मैं एक एल्गोरिथ्म लागू कर रहा हूं जो काफी कम्प्यूटेशनल रूप से जटिल होने वाला है, और यह सुनिश्चित करने की कोशिश करना चाहता हूं कि मैं अनावश्यक काम नहीं कर रहा हूं।

एक nxnxn घन जाली है, उदाहरण के लिए यदि n = 2 में यह (0,0,0), (0,1,0), (1,0,0), (1,1,0), (0) शामिल है। 1,1), (0,0,1), (1,0,1), (1,1,1)।

इस जाली से मैं पुन: m बिंदुओं के सभी सेट उत्पन्न करूंगा, कुछ इस प्रकार है:

solve(set_of_points) {
     if set_of_points.size = m, finish

     do some useful computation here

     for each point in lattice not in set_of_points:
         solve(set_of_points + new_point);
}

इसे तब एक खाली set_of_point से शुरू किया जा सकता है।

समस्या की प्रकृति ऐसी है कि मुझे वास्तव में मीटर के प्रत्येक क्रमांक की आवश्यकता नहीं है , बस वे जो क्यूब के प्राकृतिक समरूपता के तहत अद्वितीय हैं।

उदाहरण के लिए, 2x2x2 घन लें और मान लें कि हम 1 अंक के सभी सेट चाहते हैं। ऊपर दिए गए बुनियादी एल्गोरिथ्म के तहत, 1 बिंदु के 8 अलग-अलग सेट हैं।

हालांकि, क्यूब के समरूपता का उपयोग करके हम इसे 1 अंक के 1 अद्वितीय सेट तक कम कर सकते हैं, क्योंकि मूल 8 के सभी क्यूब के समरूपता के तहत बराबर हैं (वे इस मामले में सभी 'कोने' हैं)।

यदि घन 2x2x2 और m = 2 है, तो बुनियादी एल्गोरिथ्म में 28 सेट हैं, लेकिन यह समरूपता के तहत सिर्फ 3 तक कम हो जाता है (जैसे {{0,0,0), (1,0,0)}, {(0 , 0,0), (1,1,0)}, {(0,0,0), (1,1,1)})

जाहिर है कि अंकों के 3 सेटों पर गणना 28 की तुलना में बहुत बेहतर है, इसलिए मेरा सवाल यह है कि मैं उन बिंदुओं के सेट को उत्पन्न नहीं करने के बारे में कैसे जाऊं जो सममित रूप से पहले से उत्पन्न सेट के बराबर हैं? या अगर यह संभव नहीं है, तो मैं कम से कम सेट की संख्या को कम कैसे कर सकता हूं।

(ध्यान दें - यदि m = 1 यह अपेक्षाकृत आसान है - बस उन बिंदुओं को चुनें जो (0,0,0) किसी भी अन्य कोने की तुलना में करीब हैं, सीमाओं पर थोड़ा ठगना है। यह m> 1 के लिए है जो यह हो जाता है) वास्तविक समस्या होना)

Comments

सममित रूप से समतुल्य आप द्वारा कौन से ऑपरेशन शामिल हैं: केंद्र के माध्यम से मिरर-प्लेन? केंद्र के माध्यम से बिंदु-उलटा? केंद्र के माध्यम से सभी तीन 4-रोटेशन-कुल्हाड़ियों?

— BmyGuest

कोई भी

— सम्‍मिलित

यदि आप अभी भी आसपास हैं, तो पुनरावृत्ति को अंकों के एम-सेट में अनुमति दी जाएगी? उदाहरण के लिए, m = 3 के लिए, {(0,0,0), (1,1,1), (0,0,0)} को एक वैध चयन माना जाता है?

— 1

@blackpen no, को 3 अद्वितीय बिंदु होने चाहिए

— rbennett485

Answer 1

मूल अवधारणा:

(1) हम बिंदु (0,0,0) को केवल 000 के रूप में देख सकते हैं। जाली में प्रत्येक बिंदु अब एक सरल अनुक्रम में आता है। पहला बिंदु 000 है, फिर 001 है, फिर 010 011 100 101 110 और 111 है। यही क्रम है कि आप उन्हें बिंदु-सेट में जोड़ने का प्रयास करेंगे।

(2) इसी तरह, सेट {(0,0,0), (0,0,1), (0,1,0)} को बस 000001010 के रूप में देखा जा सकता है, और सेट {(0,0,0) ; आइए इसे सेट-वैल्यू कहते हैं। एन बिंदुओं के प्रत्येक संभावित सेट का अब एक सेट-मूल्य है, और एन बिंदुओं के सभी संभावित सेट अब एक साधारण सुव्यवस्थित सूची में आते हैं।

(३) प्रत्येक आइसोमॉर्फिक समूह के बिंदु-समुच्चय में ठीक एक सदस्य होता है जिसका सेट-वैल्यू सबसे कम होगा। केवल वही हैं जहां हम वास्तव में "उपयोगी संगणना" करते हैं।

(४) यहाँ वह भाग है जिसके लिए महत्वपूर्ण कार्य की आवश्यकता होगी। इससे पहले कि आप हल (set_of_point + new_point) चलाते हैं, आप यह देखना चाहते हैं कि क्या कोई समरूपता set_of_point + new_point के लिए सेट-मूल्य कम करेगा या नहीं। यदि कोई समसामयिकता सेट मान को कम करेगा तो यह समस्थानिक-समुच्चय का न्यूनतम मान सदस्य नहीं है। हम इस new_point पर कोई भी काम करना छोड़ देते हैं। हम उन सभी पुनरावर्ती कार्यों को भी छोड़ रहे हैं जो हमने इस हल (set_of_point, Candid_point) के अंदर किए होंगे।

solve(set_of_points,new_point) {
 set_of_points = set_of_points + new_point
 do some useful computation here
 if set_of_points.size = m, compute how many isomophisms exist, apply that multiple, finish
 for(candidate_point = new_point+1 to last_point) { /skips point-permutations for free!/
  if ISOMORPH_TESTS_CANNOT_LOWER_VALUE_OF(set_of_points+candidate_point) {
   solve(set_of_points,candidate_point);
  }
 }
}

Answer 2

उपरोक्त उत्तर का अंकन।

फ़ंक्शन फ़ंक्शन द्वारा प्रस्तावित सिमरट्री को पहले परिभाषित करने देता है (दिशा, संख्या_ऑफ़_टाइम)

समाधान:

(1) प्रत्येक पर ध्वज = 0 के साथ क्रमचय के सभी सेट का हैश बनाएँ। उदाहरण के लिए n = 2, m = 2 000,001 = 0 000,010 = 0 000,011 = 0 ect '...

(2) init सेट से शुरू होता है, उदाहरण के लिए i = 000,001

(3) उदाहरण के लिए रोटेट फ़ंक्शन (या कोई अन्य समरूपता) का उपयोग करके सेट i को सभी दिशा में घुमाएं। रोटेशन के प्रत्येक क्रमचय के लिए रोटेट फ़ंक्शन को 24 बार कॉल किया जाना चाहिए।

अन्वेषण: कोई भी संख्या 1-6 आपके सामने हो सकती है और प्रत्येक संख्या को 4 बार घुमाया जा सकता है, इसलिए 6 * 4 = 24

(4) प्रत्येक सेट के लिए संयोजन से पुनःप्राप्त, हैश का झंडा 1 पर सेट करें (यह पहले से ही सममित सेट है)

(5) i को अगले सेट पर अपडेट करें उदाहरण के लिए i = 000,010

(6) अगर हैश में सेट मैं पहले से ही चिह्नित है, तो (5) पर जाएं (3)

हम सभी हैश 1 के रूप में चिह्नित किया जाता है जब किया जाता है।

Comments

मैं इस दृष्टिकोण को काफी पसंद करता हूं, लेकिन यह सब मूल समस्या के लिए उपयोगी नहीं होगा (यह नहीं कि मैंने आपको बताया कि यह क्या था!)। इसका कारण यह है कि इसके लिए अभी भी प्रत्येक सेट की पीढ़ी की आवश्यकता है, और मुझे प्रत्येक सेट के साथ जो काम करना था, वह बहुत छोटा था, इसलिए यह संभवतः उतना ही उपरिशायी जोड़ देगा जितना इसे बचाया गया था। प्रत्येक सेट के लिए बहुत सारे संगणना वाले अनुप्रयोगों के लिए, हालांकि यह आसान होगा

— rbennett485

Answer 3

नोट: मुझे लगता है कि केवल दर्पण समरूपता के बारे में, यहाँ घूर्णी समरूपता नहीं।

मान लीजिए कि हमारे पास d आयामों का (हाइपर) घन है , प्रत्येक n इकाई लंबा (एक रुबिक का घन d = 3, n = 3 होगा )।

एक भोली एल्गोरिथ्म अंक के n ^ d संयोजनों को उत्पन्न करेगा , और सभी के साथ एक समरूपता संघर्ष के लिए प्रत्येक की जांच करेगा।

अगर हम बिट वेक्टर n ^ d बिट्स के रूप में बिंदुओं के संयोजन का प्रतिनिधित्व करते हैं , तो हम बिट वेक्टर के सभी समरूपों को सही करने के लिए एक नक्शा (बिट वेक्टर -> बूलियन) का उपयोग कर सकते हैं । यदि यह पहले से ही मानचित्र में चिह्नित है, तो हम एक संयोजन छोड़ सकते हैं।

यह दृष्टिकोण बहुत ही अंतरिक्ष-अक्षम है: यह 2 ^ (एन ^ डी) प्रविष्टियों के साथ एक मानचित्र लेता है , अर्थात, यह कई बिट्स के साथ बिटमैप है। (रूबिक के घन के लिए, यह 2 ^ 27 = 128Mbit = 16 Mbytes होगा।)

हम केवल कैनोनिकल अभ्यावेदन को याद कर सकते हैं, अर्थात्, ऐसे बिट वैक्टर जिनके पास सबसे छोटा पूर्णांक मान है, यदि n ^ d -bit अहस्ताक्षरित शब्द के रूप में दर्शाया गया है । जब हम अंकों का एक नया क्रम उत्पन्न करते हैं, तो हम इसकी सभी समरूपताएँ उत्पन्न करते हैं, और केवल यह जाँचते हैं कि हमने सबसे छोटे संख्यात्मक मान के साथ समरूपता देखी है या नहीं। यह हमें केवल 2 ^ n बिट्स (रुबिक के क्यूब के लिए सिर्फ 1 बाइट) का नक्शा स्टोर करने की अनुमति देगा , क्योंकि हमारे पास 2 ^ डी समरूपताएं हैं। यह हमें प्रत्येक चरण पर ये 2 ^ d समरूपता उत्पन्न करता है , हालांकि, हम O (2 ^ (d ^ n + d)) = O (2 ^ (d ^ n) * 2 ^ d) समय व्यतीत करते हैं। फिर भी गरीब है।

हम पिछले पैराग्राफ से विचार को 1-आयामी मामले में लागू कर सकते हैं। D की एक वेक्टर में सभी संयोजनों को उत्पन्न करने के लिए , हम बस एक बाइनरी नंबर d बिट्स को बढ़ा सकते हैं, जो सभी 0s से शुरू होता है । आइए हमारे वेक्टर को दो d / 2- लॉन्ग सेगमेंट में विभाजित करें, जैसे बाएं और दाएं। हम देख सकते हैं कि 1बाएं खंड में प्रत्येक बिट के लिए हमें केवल उन संयोजनों को देखने की आवश्यकता है 1जो सही अनुभाग के सममित स्थिति में हैं। अन्यथा हम पहले ही सममित संयोजन उत्पन्न कर चुके होते हैं, जब बिट्स के पदों की अदला-बदली होती है, और 0इससे पहले आया है 1। इस तरह, दाहिने आधे (आर) में हर बिट स्थिति के लिए , और बाएं आधे में सममित स्थिति(l) हमें केवल 3 संयोजनों को उत्पन्न करने की आवश्यकता है: (l = 0, r = 0); (एल = 1, आर = 1); (एल = 1, आर = 0) । इस प्रकार हमें केवल 2 ^ (d / 2) लंबाई d के वेक्टर के क्रमांक उत्पन्न करने की आवश्यकता है , प्रत्येक क्रमांकन के लिए 3 संयोजनों की उपज।

घ आयामों का एक घन n ^ (डी -1) वैक्टर का निर्माण किया जा सकता है। ऊपर की चाल हमें भोले दृष्टिकोण से सस्ता वैक्टर देती है। घन उत्पन्न करने के लिए, हमें O (n ^ (d-1) * 2 ^ (d / 2)) समय चाहिए।

यदि हम अपने 1-आयामी वैक्टर के आयाम के साथ क्यूब को देखते हैं, तो हम देख सकते हैं कि हमें इस आयाम के साथ समरूपता की जांच करने की आवश्यकता नहीं है: क्यूब्स उत्पन्न करते समय, हम प्रत्येक शामिल वेक्टर के लिए समरूपता को समाप्त करते हैं।

अब अगर हम देखने के लिए भर में इस आयाम, हम एक ही चाल का पुन: उपयोग कर सकते हैं।

जब हम आर-पार देखते हैं, तो हम देखते हैं कि किसी विशेष विमान को बनाने वाले वैक्टर के पहले टुकड़े। ये बिट्स 1-आयामी बिट वेक्टर का प्रतिनिधित्व करते हैं। हम समरूपता कारणों से इसके बिट्स के अधिकांश संयोजनों को समाप्त कर सकते हैं, जैसा कि ऊपर वर्णित है। इसलिए यदि हम किसी घन के 1-d वेक्टर (जैसे सबसे ऊपरी भाग) को चुनते हैं, तो हम किसी विशेष बिट के मान के आधार पर एक ही विमान (जैसे शीर्ष) के कई वैक्टर को समाप्त कर सकते हैं। तो हवाई जहाज पर दर्पण-सममित स्थिति में एक वेक्टर के लिए, हम सभी संयोजनों को उत्पन्न करने से बच सकते हैं जो कि बिट सेट (या परेशान) हो सकते हैं, हमें किसी विशेष विमान के लिए उत्पन्न होने वाले वैक्टर की संख्या को काफी कम कर सकते हैं। प्रत्येक समाप्त बिट मिरर परिलक्षित स्थिति में संभव वैक्टर की संख्या को आधा कर देता है। यह हमें प्रत्येक आयाम के साथ सममित समकक्षों के बिना विमानों का एक क्रम देता है।

इस चाल को तीसरे आयाम के साथ निम्नलिखित विमानों के क्रमपरिवर्तन की अगली पीढ़ी पर लागू किया जा सकता है, आदि।

हालांकि एक पूर्ण एल्गोरिथ्म नहीं, मुझे आशा है कि यह मदद करता है।