👿 ✨ ⛵️ यह देखना कि एक बिंदु एक गैर-उत्तल बहुभुज से संबंधित है 🛎️ 👶🏽 😎

यह सत्यापित करना मुश्किल नहीं है कि एक बिंदु रैखिक समय में गैर-उत्तल बहुभुज से संबंधित है। सबसे आम तरीकों में से एक बीम डालना और चौराहे के बिंदुओं की संख्या की गणना करना है। हालांकि, उन मामलों पर सावधानीपूर्वक विचार करना आवश्यक है जहां बहुभुज के बिंदु बीम पर आते हैं। यह स्वाभाविक रूप से सवाल उठाता है कि इन मामलों को सबसे आसान कैसे माना जाए?

कार्य विवरण

हम एक समस्या का एक प्रकार हल करेंगे जिसमें बहुभुज के कोने और परीक्षण के तहत बिंदु 10 ⁸ तक पूर्णांक निर्देशांक द्वारा दिए गए हैं। सरलता की कमी के लिए, हम बहुभुज के कोने पर कोई प्रतिबंध नहीं लगाएंगे। आइए हम संयोग से लंबवत, पक्षों पर कोने, आत्म-स्पर्श और शून्य क्षेत्र को हल करें। हम स्वयं-चौराहों को मना करते हैं, अन्यथा परिणामस्वरूप टूटी हुई रेखा के इंटीरियर को निर्धारित करना संभव नहीं है। यदि पॉलीगॉन की सीमा पर बिंदु निहित है, तो कार्यक्रम को 0 वापस आना चाहिए, अन्यथा, यदि पॉलीगोन के बाहर और -1 पॉलीगॉन के अंदर स्थित है तो यह 1 वापस आ जाना चाहिए।

सामान्य समाधान योजना

आज्ञा देना x ₁ , x ₂ , ..., x _n बहुभुज के कोने हैं (इन्हें क्लॉक वाइज या वामावर्त के रूप में निर्दिष्ट किया जा सकता है), y वह बिंदु है जिसे हमें जांचने की आवश्यकता है। यदि n = 1 है, तो यह y और x ₁ की समानता को सत्यापित करने के लिए पर्याप्त है। अन्यथा, हम अभिव्यक्ति की गणना करते हैं एफ ( y ) = एफ ( एक्स ₁ , एक्स ₂ , वाई ) · एफ ( एक्स ₂ , एक्स ₃ , वाई ) · साइंलेंसर एफ ( एक्स _{एन -1} , एक्स _एन , वाई ) · एफ ( एक्स _एन , एक्स ₁ , वाई )। फ़ंक्शन f ( a , b , c ) मान 1, 0, -1 लेता है। यह निर्धारित करता है कि बिंदु एक्स से साथ निकली हुई किरण एक्स सेगमेंट ( ए , बी ) की दिशा में एक्स अक्ष के साथ पार करती है , सभी चरम मामलों को ध्यान में रखते हुए। चौराहे के मामले में, यह -1 वापस आ जाएगा। यदि बिंदु c सेगमेंट ( a , b ) पर स्थित है, तो यह 0 पर वापस आएगा, अन्यथा यह 1 पर लौटेगा।

1 और -1 मामले

हम फंक्शन को ऑप्टिमाइज़ करते हैं

एक बिंदु बहुभुज से संबंधित है या नहीं, यह जांचने की पूरी जटिलता फ़ंक्शन में केंद्रित है। इसलिए, मुझे इसके कार्यान्वयन को सुलझाने और उनके बीच सबसे छोटा खोजने का विचार था। यह स्पष्ट है कि फ़ंक्शन f में पहला चरण निर्देश c और b के सापेक्ष निर्देशांक की गणना है। इन निर्देशांकों को स्थानीय चर ax , ay , bx और by । कार्यान्वयन की जांच करने के लिए, मैंने 5 से अधिक नहीं निर्देशांक वाले सभी संभव खंडों ( ए , बी ) का निर्माण किया और उनके लिए सही उत्तर पाए। इसके अलावा, मैंने उन अभिव्यक्तियों को सीमित किया है जिनका उपयोग f से signum(ax * by - ay * bx) , signum(ax) , signum(bx) , signum(ay) , signum(by) । इस प्रकार, फ़ंक्शन f को इन 5 मूल्यों के मूल्य के आधार पर एक उत्तर देना चाहिए, जो मान -1, 0 या 1 ले सकता है।
शुरुआत में, मैंने इन राशियों के रैखिक संयोजन के संकेत के रूप में उत्तर को व्यक्त करने की कोशिश की। दुर्भाग्य से, इसमें से कुछ भी नहीं आया। अगला विचार नेस्टेड ifs की एक श्रृंखला का उपयोग करना है। कार्यक्रम की जटिलता के रूप में, हम ifs की संख्या + रिटर्न की संख्या चुनते हैं। Ifs के लिए शर्तों के रूप में, हम S में फॉर्म v _i की अभिव्यक्तियों की अनुमति देते हैं, जहाँ v _i , ऊपर दिए गए 5 signum एक्सप्रेशंस में से एक है, और S {-1, 0, 1} का सबसेट है।
अब आप एक कार्यक्रम शुरू कर सकते हैं। इनपुट के रूप में, एन्यूमरेशन फ़ंक्शन प्रत्येक 5 चर के लिए अनुमत मानों का एक सेट और इन स्थितियों को पूरा करने वाले परीक्षण संख्याओं के एक सेट को स्वीकार करता है। नतीजतन, एन्यूमरेशन फ़ंक्शन न्यूनतम जटिलता के साथ एक फ़ंक्शन ट्री का उत्पादन करता है, जो सभी परीक्षण पास करता है। खोज को गति देने के लिए, सभी परिणामों को संग्रहीत किया जाता है और फिर से गणना नहीं की जाती है।
कुछ सेकंड में पूरा होने वाले कार्यक्रमों की पूरी गणना के लिए विकल्पों की संख्या काफी कम हो गई। नतीजतन, जटिलता 27 के साथ कार्यक्रम इष्टतम हो गया। मैंने प्रपत्र v _i और - v _i की अभिव्यक्तियों को स्थिरांक के अलावा वापस करने की अनुमति दी, जटिलता 18 तक गिर गई। यह अभी भी बहुत अधिक है। कार्यक्रम के एक सावधानीपूर्वक अध्ययन ने संकेत ax और bx जांच करते समय एक xor जैसी संरचना का पता लगाया। इसलिए, मैंने चर signum(ax * bx) जोड़ा और जटिलता 13. पर गिर गई। चर signum(ay * by) के अतिरिक्त के साथ प्रयोग ने जटिलता को घटाकर 11. कर दिया। परिणाम निम्न कार्य था:

 public static int check2(Point a, Point b, Point middle) { long ax = ax - middle.x; long ay = ay - middle.y; long bx = bx - middle.x; long by = by - middle.y; if (ay * by > 0) return 1; int s = Long.signum(ax * by - ay * bx); if (s == 0) { if (ax * bx <= 0) return 0; return 1; } if (ay < 0) return -s; if (by < 0) return s; return 1; }

यह पहले से ही लाइनों की संख्या के मामले में थोड़ा कम निकला और मूल संस्करण के पात्रों की संख्या के संदर्भ में काफी कम था, जिसका उपयोग परीक्षणों को उत्पन्न करने के लिए किया गया था। इस कार्यक्रम की छोटी लंबाई याद रखने में आसान बनाती है:

शुरुआत में, हम जांचते हैं कि खंड ( ए , बी ) किरण के एक तरफ कड़ाई से स्थित है या नहीं। इस मामले में, निश्चित रूप से कोई चौराहा नहीं है।
जब बिंदु c लाइन ( a , b ) पर होता है तो हम पतित मामले को सत्यापित करते हैं। शून्य के उत्तर को केवल तभी टाला जा सकता है जब अंक y अक्ष के एक तरफ स्थित हों। यदि वे दोनों y अक्ष पर झूठ बोलते हैं, तो मामला जब c सेगमेंट पर झूठ नहीं बोलता है ( a , b ) पहले से ही पिछले खंड में माना जाता है।
एक खंड के साथ एक किरण के चौराहे की जाँच के लिए Xor जैसा कोड। s का संकेत इस बात पर निर्भर करता है कि किरण के नीचे कौन सा बिंदु है। यहाँ आप दो में से किसी एक मामले में माइनस लगा सकते हैं; कम संकेत, अधिक या कम या बराबर के साथ बदलें।
हम उस स्थिति में 1 वापस आते हैं जब एक बिंदु बीम पर स्थित होता है, और दूसरा इसके कुछ निश्चित तरफ होता है। इस तरह के चौराहों की गिनती नहीं की जाती है ताकि एक चौराहे को दो बार गिना न जाए यदि बहुभुज का शीर्ष एक किरण से टकराता है।

लेकिन यह सीमा नहीं है! इस कार्यान्वयन में, ay by गुणा by । क्यों इसे ay < 0 ^ by < 0 तरह कुछ के साथ प्रतिस्थापित करके गुणा से छुटकारा नहीं मिलता है? परिणाम काफी समान नहीं है, लेकिन आप इस चर को खोज में जोड़ सकते हैं और देख सकते हैं कि क्या होता है। एल्गोरिथ्म का अगला रन ... और यह जटिलता 9 के साथ एक समाधान पैदा करता है! नया विकल्प इस तरह दिखता है:

 public static int check3(Point a, Point b, Point middle) { long ax = ax - middle.x; long ay = ay - middle.y; long bx = bx - middle.x; long by = by - middle.y; int s = Long.signum(ax * by - ay * bx); if (ay < 0 ^ by < 0) { if (by < 0) return s; return -s; } if (s == 0 && ax * bx <= 0) return Long.signum(ay * by); return 1; }

आप इसे थोड़ा और परिष्कृत कर सकते हैं। Long.signum(ay * by) ay < 0 ^ by < 0 लिए ay < 0 ^ by < 0 जाँच करने के बाद ay < 0 ^ by < 0 मान Long.signum(ay * by) -1 नहीं के बराबर हो सकता है। इसलिए, अंतिम पंक्तियों को फिर से लिखा जा सकता है:

 public static int check3(Point a, Point b, Point middle) { long ax = ax - middle.x; long ay = ay - middle.y; long bx = bx - middle.x; long by = by - middle.y; int s = Long.signum(ax * by - ay * bx); if (ay < 0 ^ by < 0) { if (by < 0) return s; return -s; } if (s == 0 && (ay == 0 || by == 0) && ax * bx <= 0) return 0; return 1; }

इस संस्करण में, दो शीर्ष-स्तर के आइफों को फिर से व्यवस्थित किया जा सकता है। माप बताते हैं कि यह सभी परीक्षणों पर परिचालन समय में एक छोटा लाभ देता है:

 public static int check3(Point a, Point b, Point middle) { long ax = ax - middle.x; long ay = ay - middle.y; long bx = bx - middle.x; long by = by - middle.y; int s = Long.signum(ax * by - ay * bx); if (s == 0 && (ay == 0 || by == 0) && ax * bx <= 0) return 0; if (ay < 0 ^ by < 0) { if (by < 0) return s; return -s; } return 1; }

नए एल्गोरिथ्म में फिर से बड़ी संख्या में स्वतंत्रता है। ay < 0 ^ by < 0 की अभिव्यक्ति ay < 0 ^ by < 0 , एक छोटे संकेत के बजाय, आप एक बड़े चिह्न या एक गैर-सख्त चिह्न का उपयोग कर सकते हैं। s पर ऋण चिह्न फिर से दो मामलों में डाला जा सकता है। by चर को नेस्टेड if'e ay में बदला जा सकता है।
नए एल्गोरिथम में सबसे मुश्किल काम शून्य के मामले को समझना है। यह एक साथ दो स्वतंत्र मामलों की जाँच करता है।

पहले मामले में, खंड ( ए , बी ) में से एक बिंदु सी के साथ मेल खाता है, दूसरे मामले में, खंड एक्स अक्ष के समानांतर है और बिंदु सी से गुजरता है। इन जाँचों को अन्य तरीकों से किया जा सकता है, लेकिन ऊपर दी गई विधि सबसे छोटी है।

सबसे खराब प्रदर्शन परीक्षण से पता चलता है कि 32-बिट जेवीएम पर, चेक 2 फ़ंक्शन चेक 3 की तुलना में तेज है। 64-बिट JVM पर, परिणाम स्पष्ट नहीं है। हालांकि, दोनों मामलों में अंतर काफी कम है - 5-10%। किसी कारण से असमानता के ax * bx <= 0 को बदलने का प्रयास जावा मशीन के 32-बिट या 64-बिट संस्करणों में ध्यान देने योग्य सुधार नहीं देता है।

जो लोग प्रयोग करना चाहते हैं, उनके लिए स्रोत: PolyCheck.zip

यह देखना कि एक बिंदु एक गैर-उत्तल बहुभुज से संबंधित है

कार्य विवरण

सामान्य समाधान योजना

हम फंक्शन को ऑप्टिमाइज़ करते हैं

More articles: