2 डी ऐरे में आकृतियाँ खोजना, फिर अनुकूलन करना

Question

मुझे बस एक छवि की अनुमति दी गई है ... मेरे खेल से नीचे की छवि कुछ अंधेरे ब्लॉकों को दिखाती है, जिन्हें "टी" आकार का हिस्सा होने के रूप में मान्यता दी गई है। जैसा कि देखा जा सकता है, कोड ने लाल धब्बों के साथ ब्लॉकों को गहरा कर दिया है, और हरे रंग की रूपरेखा के साथ "टी" आकार नहीं देखा है।

मेरा कोड x / y के माध्यम से लूप करता है, ब्लॉक का उपयोग करता है, आकार को घुमाता है, दोहराता है, रंग बदलता है, दोहराता है।

मैंने इस जाँच को बहुत ही तीखेपन के साथ ठीक करने की कोशिश शुरू कर दी है। वर्तमान विचार यह है:

• ग्रिड के माध्यम से लूप करें और सभी पैटर्न घटनाओं को नोट करें (उपयोग किए गए ब्लॉकों को चिह्नित नहीं करें), और इन्हें एक सरणी में डाल दें
• फिर से ग्रिड के माध्यम से लूप, इस बार यह देखते हुए कि कौन से ब्लॉक किस पैटर्न पर कब्जा कर रहे हैं, और इसलिए कई पैटर्न पर कब्जा कर लिया गया है।
• फिर से ग्रिड के माध्यम से लूपिंग, इस बार ध्यान देने योग्य है कि कौन से पैटर्न किस पैटर्न को बाधित करते हैं

यह बहुत सही लगता है ... अब मैं क्या करूँ?

मुझे लगता है कि मुझे करना होगा

• परस्पर विरोधी आकृतियों के विभिन्न संयोजनों को आज़माएं, उन लोगों के साथ शुरू करें जो पहले सबसे अन्य पैटर्न को बाधित करते हैं। मैं इसे कैसे एप्रोच करूं?
• तर्कसंगत का उपयोग करें जो कहता है कि मेरे पास 8 ब्लॉकों पर कब्जा करने वाले 3 परस्पर विरोधी आकार हैं, और आकार प्रत्येक 4 ब्लॉक हैं, इसलिए मेरे पास अधिकतम दो आकार हो सकते हैं।

(मैं अन्य आकृतियों को शामिल करने का भी इरादा रखता हूं, और संभवत: स्कोर वेटिंग होगा, जिसे परस्पर विरोधी आकृतियों से गुजरने पर विचार करने की आवश्यकता होगी, लेकिन यह एक और दिन हो सकता है)

मुझे नहीं लगता कि यह बिन पैकिंग की समस्या है, लेकिन मुझे यकीन नहीं है कि क्या देखना है। आशा है कि समझ में आता है, आपकी मदद के लिए धन्यवाद

EDIT प्रश्न की स्पष्टता के बावजूद, सभी को समझ में आ गया है, हाँ,

मैं प्रत्येक रंग के भीतर अधिकतम "टी" आकार ढूंढना चाहता हूं

(क्योंकि अगर मैंने आपको दो अंक दिए थे और आपने तीन बनाए थे, तो आप थोड़ा नाराज होंगे)

Comments

एक लालची एल्गोरिथ्म कपल्ड को शामिल किए गए ब्लॉकों के संग्रह में बोर्ड को विभाजित करने के लिए होना चाहिए। फिर प्रत्येक संग्रह के लिए आप आकृतियों के साथ भरने की कोशिश कर सकते हैं और भरे हुए स्कोर को छोड़ दिए गए ब्लॉकों की मात्रा पर निर्भर कर सकते हैं जो अंधेरा नहीं होगा। की तरह मुझे en.wikipedia.org/wiki/Knapsack_problem के बारे में सोचता है ।

— जोनाथन कॉनेल

मुझे लगता है कि सवाल में कुछ कमी है। क्या आप एक एल्गोरिथ्म बनाना चाहते हैं जो यथासंभव "टी" आकार के समूहों को ढूंढता है?

— मार्कस वॉन ब्रॉडी

अगर मैं तुम्हें समझूं तो तुम सही तरीके से आगे बढ़ रहे हो। आप अत्यधिक स्पष्ट नहीं हैं और अगर आप विस्तृत रूप से बताएंगे तो मुझे अच्छा लगेगा।

— AturSams

Answer 1

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

यदि मैं सही हूं तो मेरी राय में आपकी स्थिति के लिए इष्टतम समाधान है।

हम Integer Linear Programming का उपयोग करेंगे।

मेरा मानना ​​है कि मैंने अतीत में इसका इस्तेमाल किया था:

http://sourceforge.net/projects/lpsolve/

http://lpsolve.sourceforge.net/5.5/Java/README.html

(आप इसे कई भाषाओं के साथ काम करने के लिए प्राप्त कर सकते हैं, मैंने इसे PHP, Java और C के साथ उपयोग किया है)

हम क्या करेंगे बोर्ड पर हर संभव टी आकार को पंजीकृत करें और फिर कवर किए गए ब्लॉकों की मात्रा को अधिकतम करने के लिए ILP का उपयोग करें। ILP तेजी से जटिल है। अपने बोर्ड के आकार को ध्यान में रखते हुए, यह एक समस्या नहीं होगी। मैंने ILP के साथ ग्राफ़ पर बहुत अधिक जटिल मिनट / अधिकतम प्रश्न चलाए हैं और यह सैकड़ों सेकंड (आपके मामले में यह एक दूसरे के अंश में गिरता है) के साथ पूरा करने के लिए एक सेकंड का एक अंश और 30-90 सेकंड तक ले गया है।

मैं क्या करने की सलाह दूंगा:

1. सभी संभव रेखा आकृतियों का पता लगाएं
2. एक ही रंग की रेखा आकृतियों के बीच सभी चौराहों का पता लगाएं
3. सभी संभव टी आकृतियों को खोजें, सभी चौराहे की खोज करें।
4. प्रत्येक T आकार के लिए रैखिक समस्या में एक बूलियन चर को परिभाषित करें ( 0 <= Bi <= 1क्योंकि मान पूर्णांक हैं, जो 0 या 1 छोड़ता है।
5. टी शेप के प्रत्येक जोड़े के लिए स्थितियां बनाएं जो प्रतिच्छेद करती हैं ( Bi + Bj <= 1)
6. उद्देश्य समारोह होगा ("T" आकार (i) * Bi) में ब्लॉक का योग
7. सॉल्वर को चलाएं और T के आकृतियों को गहरा करें जहां सॉल्वर के संबंधित बूलियन (s) जहां इष्टतम समाधान में 1 है।

यह मूल्यवान ज्ञान है, मैंने काम की परियोजनाओं के लिए अक्सर रैखिक सॉल्वर का उपयोग किया।

ILP मूल रूप से चयन समस्याओं को हल करने का एक तरीका है जहां आप कुछ रैखिक फ़ंक्शन के लिए अधिकतम या न्यूनतम प्राप्त करना चाहते हैं।

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

मुझे लगता है कि आप यहाँ और अधिक पढ़ सकते हैं:

http://en.wikipedia.org/wiki/Integer_linear_programming#Integer_unknowns

यह इसे अच्छी तरह से समझाता है:

http://fisher.osu.edu/~croxton_4/tutorial/

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

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

मुझे पता है कि यह तुच्छ नहीं है इसलिए यदि आप छलांग लेने का विकल्प चुनते हैं, तो बेझिझक टिप्पणी करें और मैं विस्तार से बताऊंगा।

Comments

आपकी मदद के लिए धन्यवाद आर्थर। यह पढ़ने के लिए कुछ पचाने के लिए ले सकता है। और हाँ, आपने समस्या को सही ढंग से समझा। मुझे बहुत दिलचस्पी होगी यदि आप विस्तृत (नहीं, नहीं, यह तुच्छ नहीं है), लेकिन इससे मुझे यह जानने में मदद मिलेगी कि मैं कहाँ जा रहा हूँ!

— असेंबलर

कार्यान्वयन के लिए आप किस भाषा का उपयोग कर रहे हैं?

— AturSams

3 कार्रवाई! सबका पसंदीदा!

— असेंबलर

मुझे भी। मैं as3 में एक कार्यान्वयन लिखूंगा और इसे टिप्पणी के साथ डाउनलोड करने के लिए एक गीथब में अपलोड करूंगा, चरण दर चरण काम कर रहा हूं - मैं इसे आज बाद में प्राप्त कर सकता हूं

— AturSams

क्या आपके पास कोई विशिष्ट क्षेत्र है 1 -7 जहां आप मुझे अधिक टिप्पणियां जोड़ना या विस्तृत करना चाहेंगे? btw, हमारे लिए AS3 प्रेमियों के लिए अच्छी खबर है, Adobe ने FlasCC जारी किया जो C ++ का समर्थन करता है ताकि हम आसानी से मौजूदा रैखिक सॉल्वर का उपयोग कर सकें। :)

— AturSams

Answer 2

एक बार जब आपके पास अपने ग्रिड में होने वाली सभी (संभवतः अतिव्यापी) टी-आकार की एक सूची होती है, तो आपके द्वारा छोड़ी गई अधिकतम पैकिंग समस्या होती है।

सामान्य तौर पर, यह एक एनपी-पूर्ण समस्या है। हालाँकि, आपका ग्रिड काफी छोटा है (और आमतौर पर छोटे स्वतंत्र उपप्रकारों में टूट जाता है) कि यह सटीक समाधान प्राप्त करने के लिए अच्छी तरह से संभव है।

---

परिशिष्ट: यहाँ एक मूल खोज विधि एल्गोरिथ्म है जो चाल कर सकता है:

function max_packing_recursive ( set A, set S, set M ):
    if |M| < |S| then let M = S;
    for each shape X in A do:
        remove X from A;
        let B = A;
        remove all shapes that intersect with X from B;
        if |M| < |B| + |S| + 1 then:        // upper bound
            let M = max_packing_recursive( B, S + {X}, M );
        end if
        if |M| >= |A| + |S| then return M;  // shortcut
    end for
    return M;
end function

function max_packing( set A ):
    return max_packing_recursive( A, {}, {} );
end function

यहाँ, {X, Y, Z}तत्वों वाले सेट को दर्शाता है X, Yऔर Z( {}खाली सेट होने के साथ ), और सेट |Q|के आकार को दर्शाता है Q।

पुनरावर्ती फ़ंक्शन में, सेट Aमें शेष समाधान के लिए उपलब्ध आकृतियाँ होती हैं, Sजिसमें वर्तमान समाधान उम्मीदवार में आकृतियाँ होती हैं, और Mअब तक का अधिकतम समाधान है (जिसे आप इसे वापस करने के बजाय एक वैश्विक चर के रूप में संग्रहीत कर सकते हैं। कॉल श्रृंखला)। महत्वपूर्ण अनुकूलन के साथ चिह्नित लाइन पर है // upper bound, जो खोज ट्री की शाखाओं को चुभता है जो संभवतः बेहतर समाधान नहीं दे सकते हैं M।

(वास्तव में, क्योंकि हम जानते हैं कि प्रत्येक टी-आकार में ठीक चार साइटें होती हैं, |B|इसलिए आकृतियों द्वारा कवर की गई अलग-अलग साइटों की संख्या के साथ Bचार और विभाजित करके और नीचे की ओर विभाजित करके बहुत बेहतर ऊपरी सीमा प्राप्त की जा सकती है (और इसी तरह इसके लिए |A|भी रेखा के साथ चिह्नित // shortcut)। एल्गोरिथ्म जैसा कि ऊपर दिया गया है, हालांकि, आकार के मनमाने संग्रह के लिए काम करता है।)

एक संभावित अतिरिक्त अनुकूलन, जिसे मैंने ऊपर लागू नहीं किया है, को पुनरावर्ती कार्य की शुरुआत में जांचना होगा कि क्या Aकई उपसमुच्चय में विभाजित हैं जो स्वतंत्र हैं, इस अर्थ में कि विभिन्न उपसमूह में कोई आकार ओवरलैप नहीं होता है, और यदि ऐसा है, तो लागू करें। प्रत्येक सबसेट के लिए अलग से एल्गोरिदम। (किसी भी मामले में, आप निश्चित रूप से पुनरावर्ती एल्गोरिथ्म को कॉल करने से पहले कम से कम एक बार शीर्ष स्तर पर ऐसा करना चाहेंगे ।) Aउन पर लूपिंग से पहले उचित रूप से आकृतियों को क्रमबद्ध करना, जैसे कि अतिव्यापी आकृतियों की संख्या से बढ़ते क्रम में, यह भी मदद कर सकता है। ।

Comments

हाँ, मुझे लगता है कि वह समस्या के आकार के कारण अपेक्षाकृत दर्द रहित तरीके से इसे हल करने के लिए ILP का उपयोग कर सकता है .. 2 ^ 20 ~ = 1,000,000 इसलिए कि केवल इतने सारे T आकार हो सकते हैं, उसे इसके लिए एक लीनियर सॉल्वर का उपयोग करना चाहिए। । यह स्पष्ट रूप से घातीय रूप से जटिल है (कम से कम जब तक कोई उस पी = एनपी को साबित करने का प्रबंधन नहीं करता है)। आकार इस अपेक्षाकृत सरल मामले में उत्तराधिकार से बचने की अनुमति देता है।

— अट्टुरसम्स

इल्मरी, बहुत-बहुत धन्यवाद। इस उत्तर को भी समझने में कुछ समय लगेगा। मनमाना आकार बिट भविष्य के पुनरावृत्तियों में उपयोगी हो सकता है।

— असेंबलर