टक्कर का पता लगाने वाले हमेशा O (n ^ 2) होते हैं?

Question

क्या भौतिकी इंजन उस जटिलता को कम करने में सक्षम है, उदाहरण के लिए उन वस्तुओं को समूहीकृत करना जो एक-दूसरे के पास हैं और सभी वस्तुओं के मुकाबले इस समूह के अंदर टकराव की जांच करते हैं? (उदाहरण के लिए, दूर की वस्तुओं को एक समूह से उसके वेग और अन्य वस्तुओं की दूरी को देखकर हटाया जा सकता है)।

यदि नहीं, तो क्या यह गोले (3 डी) या डिस्क (2d में) के लिए टकराव को तुच्छ बनाता है? क्या मुझे एक डबल लूप बनाना चाहिए, या इसके बजाय एक जोड़ी बनाना चाहिए?

EDIT: बुलेट और बॉक्स 2 डी जैसे भौतिकी इंजन के लिए, टक्कर का पता लगाना अभी भी हे (एन ^ 2) है?

Comments

दो शब्द: स्थानिक विभाजन

— MichaelHouse

यहाँ देखें: gamedev.stackexchange.com/questions/14373/find-nearest-object

— MichaelHouse

बिलकुल। मेरा मानना ​​है कि दोनों में SAP ( स्वीप और प्र्यून ) (अन्य लोगों के बीच) का कार्यान्वयन है जो एक O (n log (n)) एल्गोरिथम है। अधिक जानने के लिए "ब्रॉड फेज कोलिजन डिटेक्शन" की खोज करें।

— MichaelHouse

@ Byte56 स्वीप और प्रून में जटिलता ओ (एन लॉग (एन)) है, अगर आपको हर बार परीक्षण करने की आवश्यकता होती है। आप वस्तुओं की एक क्रमबद्ध सूची रखना चाहते हैं और हर बार जब आप एक जोड़ते हैं, तो इसे सही जगह ओ (लॉग (एन)) में सॉर्ट करें इसलिए आपको ओ (लॉग (एन) + एन) = ओ (एन) मिलता है। यह बहुत जटिल हो जाता है जब वस्तुएं चलना शुरू कर देती हैं!

— मार्टिनटार्गा

@ sm4, यदि आंदोलनों को सीमित किया जाता है तो बबल सॉर्ट के कुछ पास ध्यान रख सकते हैं (बस स्थानांतरित वस्तुओं को चिह्नित करें और उन्हें सॉर्ट किए जाने तक आगे या पीछे की ओर ले जाएं। बस अन्य चाल वस्तुओं के लिए बाहर देखें

— शाफ़्ट फ्रीक।

Answer 1

स्थानिक विभाजन हमेशा सबसे खराब स्थिति में O (N ^ 2) होता है और यही सूचना विज्ञान में जटिलता है।

हालांकि एल्गोरिदम हैं जो रैखिक समय ओ (एन) में काम करते हैं । ये सभी किसी न किसी तरह की स्वीप लाइन पर आधारित हैं।

मूल रूप से आपको अपनी वस्तुओं को एक समन्वय द्वारा क्रमबद्ध करना होगा। मान लें कि X. यदि आप टकराव का पता लगाने से पहले हर बार प्रदर्शन करते हैं, तो जटिलता O (N * logN) होगी। ट्रिक केवल तब सॉर्ट करना है जब आप वस्तुओं को दृश्य में जोड़ रहे हैं और बाद में जब दृश्य में कुछ बदलता है। आंदोलन के बाद छंटनी तुच्छ नहीं है। एक एल्गोरिथ्म के लिए नीचे दिए गए लिंक किए गए पेपर को देखें जो आंदोलन में ले जाता है और अभी भी रैखिक समय में काम करता है।

फिर आप बाएं से दाएं स्वीप करें। हर बार जब आपकी स्वीप लाइन किसी वस्तु की शुरुआत को पार करती है, तो आप इसे एक अस्थायी सूची में डाल देते हैं। हर बार जब आपकी स्वीप लाइन ऑब्जेक्ट से बाहर निकलती है, तो आप इसे सूची से निकाल लेते हैं। आप केवल इस अस्थायी सूची के अंदर टकराव पर विचार करते हैं।

भोली स्वीप लाइन सबसे खराब स्थिति में O (N ^ 2) है (आप सभी वस्तुओं को बाएं से दाएं तक पूरे नक्शे पर फैलाते हैं), लेकिन आप इसे और अधिक स्मार्ट (नीचे लिंक देखें) करके O (N) बना सकते हैं। वास्तव में अच्छा एल्गोरिथ्म काफी जटिल होगा।

यह सरल आरेख है कि स्वीप लाइन कैसे काम करती है:

रेखा बाएँ से दाएँ जाती है। वस्तुओं का समन्वय एक्स द्वारा किया जाता है।

• केस एक: पहले दो वस्तुओं की जाँच की जाती है। और कुछ मायने नहीं रखता है।
• केस दो: पहले ऑब्जेक्ट की जाँच की गई और सूची से चला गया। दो और तीन की जाँच की जाती है।
• केस तीन: भले ही वह वस्तु टकरा रही हो, हम जांच नहीं करते हैं।
• केस चार: क्योंकि हम इस मामले में जाँच करते हैं!

इस तरह के एल्गोरिदम में जटिलता ओ (सी * एन) = ओ (एन) है।

स्रोत: कम्प्यूटेशनल ज्यामिति पाठ्यक्रमों के दो साल।

टक्कर का पता लगाने में इसे आम तौर पर स्वीप और प्र्यून कहा जाता है , लेकिन कई अन्य क्षेत्रों में एल्गोर्टिथम्स का स्वीप लाइन परिवार उपयोगी है।

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

---

अब ध्यान दें कि यह सिद्धांत में सबसे अच्छा एल्गोरिथ्म है । इसका मतलब यह नहीं है कि इसका उपयोग किया जाता है। व्यवहार में, स्थानिक विभाजन के साथ O (N ^ 2) एल्गोरिथ्म में विशिष्ट मामले में बेहतर प्रदर्शन की गति बुद्धिमान होगी (O (N) के करीब) और स्मृति के लिए कुछ अतिरिक्त आवश्यकता। ऐसा इसलिए है क्योंकि O (C * N) में निरंतर C बहुत अधिक हो सकता है! चूंकि हमारे पास आमतौर पर पर्याप्त मेमोरी होती है और विशिष्ट मामलों में अंतरिक्ष में समान रूप से वस्तुओं का प्रसार होता है - ऐसे एल्गोरिदम बेहतर प्रदर्शन करेंगे। लेकिन ओ (एन) मूल प्रश्न का उत्तर है।

Comments

बॉक्स 2d / बुलेट इसका उपयोग करता है?

— जकून

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

— शॉन मिडिलडविच

चूंकि तकनीकी रूप से वास्तव में O (N ^ 2) जोड़ीदार टक्कर हो सकती है, इसलिए यह कहना पूरी तरह सच नहीं है कि स्वीप-एंड-प्रून हमेशा O (N) होता है। बल्कि, एल्गोरिथ्म की मुख्य जटिलता ओ (एन + सी) है, जहां सी एल्गोरिथ्म द्वारा पाई जाने वाली टक्करों की संख्या है - यह आउटपुट-संवेदनशील है , बहुत से उत्तल पतवार एल्गोरिदम हैं। (संदर्भ: en.wikipedia.org/wiki/Output-sensitive_algorithm )

— स्टीवन स्टैडनिक

आपको कुछ प्रकाशनों या कम से कम एल्गोरिदम नामों के साथ अपने दावों को वापस लेना चाहिए।

— सम होसीवर

@SamHocevar मैंने एक बहुत ही उन्नत स्वीप और प्रून एल्गोरिथ्म का लिंक जोड़ा है, जो स्थिरांक के विस्तृत टूटने के साथ रैखिक समय में काम करता है। यह तथ्य कि एल्गोरिदम को "स्वीप और प्रून" कहा जाता है, मेरे लिए नया था, क्योंकि मैंने इसके साथ कभी काम नहीं किया। मैंने इन एल्गोरिदम का उपयोग मानचित्र चयन में किया है (जो अन्य वस्तुओं के साथ 1 बिंदु की टक्कर की तरह है), इसलिए मैंने सिर्फ ज्ञान लागू किया।

— मार्टिनटेगा

Answer 2

नहीं। टकराव का पता लगाना हमेशा O (N ^ 2) नहीं होता है।

उदाहरण के लिए, मान लें कि हमारे पास 100x100 की जगह है जिसमें आकार 10x10 है। हम एक ग्रिड के साथ इस जगह को 10x10 की कोशिकाओं में विभाजित कर सकते हैं।

प्रत्येक वस्तु 4 ग्रिड कोशिकाओं तक हो सकती है (यह एक ब्लॉक में सही बैठ सकती है या "कोशिकाओं के बीच" हो सकती है)। हम प्रत्येक सेल में वस्तुओं की एक सूची रख सकते हैं।

हमें केवल उन कोशिकाओं में टकराव की जाँच करने की आवश्यकता है। यदि प्रति ग्रिड सेल में वस्तुओं की अधिकतम संख्या है (कहते हैं, एक ही ब्लॉक में 4 से अधिक ऑब्जेक्ट्स कभी नहीं होते हैं), तो प्रत्येक ऑब्जेक्ट के लिए टकराव का पता लगाना ओ (1) है और सभी वस्तुओं के लिए टकराव का पता लगाना ओ (एन) है।

यह ओ (एन ^ 2) जटिलता से बचने का एकमात्र तरीका नहीं है। अन्य तरीके हैं, अन्य उपयोग-मामलों के लिए अधिक पर्याप्त हैं - अक्सर पेड़-आधारित डेटा संरचनाओं का उपयोग करना।

मैंने जो एल्गोरिथ्म का वर्णन किया है, वह एक प्रकार का Space विभाजन है , लेकिन अन्य अंतरिक्ष विभाजन एल्गोरिदम हैं। कुछ और एल्गोरिदम के लिए अंतरिक्ष विभाजन डेटा संरचनाओं के प्रकार देखें, जो O (N ^ 2) अस्थायी जटिलता से बचते हैं।

बॉक्स 2 डी और बुलेट दोनों चेक किए गए जोड़ों की संख्या को कम करने के लिए तंत्र का समर्थन करते हैं।

से मैनुअल , खंड 4.15:

एक भौतिकी कदम में टकराव की प्रक्रिया को संकीर्ण-चरण और व्यापक-चरण में विभाजित किया जा सकता है। संकीर्ण-चरण में हम आकृतियों के जोड़ों के बीच संपर्क बिंदुओं की गणना करते हैं। कल्पना कीजिए कि हमारे पास एन आकार हैं। जानवर बल का उपयोग करते हुए, हमें एन * एन / 2 जोड़े के लिए संकीर्ण-चरण प्रदर्शन करना होगा।

B2BroadPhase वर्ग जोड़ी प्रबंधन के लिए एक गतिशील पेड़ का उपयोग करके इस भार को कम करता है। यह संकीर्ण-चरण कॉल की संख्या को बहुत कम करता है।

आम तौर पर आप सीधे व्यापक-चरण के साथ बातचीत नहीं करते हैं। इसके बजाय, Box2D आंतरिक रूप से एक व्यापक चरण का निर्माण और प्रबंधन करता है। इसके अलावा, b2BroadPhase को Box2D के सिमुलेशन लूप को ध्यान में रखकर बनाया गया है, इसलिए यह अन्य उपयोग के मामलों के लिए अनुकूल नहीं है।

से गोली विकी :

विभिन्न प्रकार के ब्रॉडफेज एल्गोरिदम हैं जो भोले ओ (एन ^ 2) एल्गोरिथ्म में सुधार करते हैं जो सिर्फ जोड़े की पूरी सूची लौटाते हैं। ये अनुकूलित ब्रॉडफेज कभी-कभी और अधिक गैर-टकराव वाले जोड़े भी पेश करते हैं लेकिन यह आम तौर पर बेहतर निष्पादन समय से ऑफसेट होता है। उनके पास अलग-अलग प्रदर्शन विशेषताएं हैं और सभी स्थितियों में कोई भी दूसरों से बेहतर प्रदर्शन नहीं करता है।

गतिशील AABB ट्री

यह btDbvtBroadphase द्वारा बुलेट में लागू किया गया है।

जैसा कि नाम से पता चलता है, यह एक गतिशील AABB पेड़ है । इस प्रसारक की एक उपयोगी विशेषता यह है कि यह संरचना दुनिया के आयामों और इसकी सामग्री के लिए गतिशील रूप से अनुकूल है। यह बहुत अच्छी तरह से अनुकूलित है और एक बहुत अच्छा सामान्य उद्देश्य है। यह गतिशील दुनिया को संभालता है जहां कई वस्तुएं गति में हैं, और ऑब्जेक्ट जोड़ और निकालना एसएपी से तेज है।

स्वीप और प्रून (SAP)

बुलेट में, यह कक्षाओं की एक्सिसस्वीप श्रेणी है। यह भी एक अच्छा सामान्य उद्देश्य ब्रॉडपेज़ है, एक सीमा के साथ कि इसे एक निश्चित विश्व आकार की आवश्यकता होती है, जिसे पहले से जाना जाता है। इस ब्रॉडपेज़ में विशिष्ट डायनामिक्स दुनिया के लिए सबसे अच्छा प्रदर्शन है, जहां अधिकांश वस्तुओं में बहुत कम या कोई गति नहीं है। दोनों btAxisSweep3 और bt32AxisSweep3 प्रदर्शन में सुधार करने के लिए फ्लोटिंग पॉइंट नंबरों के बजाय पूर्णांक के रूप में प्रत्येक अक्ष के लिए आरंभ और अंत बिंदुओं को निर्धारित करते हैं।

निम्नलिखित लिंक ब्रॉडपेज़ के लिए एक सामान्य परिचय है और स्वीप और प्रून एल्गोरिथ्म का वर्णन भी है (हालांकि इसे "सॉर्ट और स्वीप" कहते हैं):

http://www.ziggyware.com/readarticle.php?article_id=128

इसके अलावा, विकिपीडिया पृष्ठ पर एक नज़र डालें:

http://en.wikipedia.org/wiki/Sweep_and_prune

Comments

इसी तरह के सवालों और बाहरी संसाधनों के कुछ लिंक इसे एक शानदार उत्तर बनाते हैं।

— MichaelHouse

ये गलत है। आपको अभी भी O (N ^ 2) मिल रहा है। यह बहुत तेज़ होगा, N ^ 2/100 जैसा कुछ, लेकिन फिर भी N ^ 2। एक प्रमाण के रूप में, बस विचार करें कि सभी ऑब्जेक्ट एक सेल में होते हैं।

— मार्टिनटेरगा

@ sm4 यह सबसे खराब स्थिति वाला O (N ^ 2) है, जो वास्तव में सभी वस्तुओं के एक सेल में होने पर होता है। हालांकि, एक भौतिकी इंजन में, ऑब्जेक्ट आमतौर पर एक सेल में नहीं होंगे। मेरे उदाहरण में, कोई भी वस्तु कभी भी एक ही सेल को 3 से अधिक अन्य वस्तुओं के साथ साझा नहीं कर सकती है। यह वही होगा जो "सामान्य" वस्तुओं के लिए एक भौतिकी इंजन में होता है (और "सामान्य" से मेरा मतलब है "न सिर्फ सेंसर")।

— ल्यूकबुल

मुझे लगता है कि आपके एल्गोरिथ्म को केवल 4 कोशिकाओं के आसपास नहीं बल्कि 8 कोशिकाओं में जांचना होगा।

— जकून

@luiscubal जटिलता हमेशा "सबसे खराब स्थिति" है। सिद्धांत रूप में आप "गारंटीकृत" जटिलता की तलाश कर रहे हैं। यह क्विकॉर्ट के साथ समान है, जो O (N ^ 2) और मर्जेसर्ट है, जो O (N * logN) है। Quicksort वास्तविक डेटा पर बेहतर प्रदर्शन करता है और इसमें स्थानिक आवश्यकता कम होती है। लेकिन विलय ने बेहतर जटिलता की गारंटी दी है। यदि आपको किसी चीज को प्रूफ करने की जरूरत है, तो मर्जर्ट का उपयोग करें। यदि आपको कुछ छाँटने की आवश्यकता है, तो क्विकॉर्ट का उपयोग करें।

— मार्टिनटेर्गा

Answer 3

ओ (एन ^ 2) इस तथ्य को संदर्भित करता है कि यदि आपके पास एन ऑब्जेक्ट्स हैं, तो पता लगाना है कि क्या टकरा रहा है, सबसे खराब स्थिति है , एन ^ 2 टकराव की गणना। कहते हैं कि आपके पास 3 ऑब्जेक्ट हैं। "कौन मार रहा है" खोजने के लिए, आपको ढूंढना होगा:

o1 hitting o2?  o1 hitting o3?
o2 hitting o1?  o2 hitting o3?
o3 hitting o1?  o3 hitting o2?

यह टकराव के लिए 6 चेक, या एन * (एन -1) चेक है। स्पर्शोन्मुख विश्लेषण में हम बहुपद और अनुमानित का विस्तार O (N ^ 2) के रूप में करेंगे। यदि आपके पास 100 वस्तुएं थीं, तो वह 100 * 99 होगी, जो कि 100 * 100 के करीब है।

इसलिए यदि आप उदाहरण के लिए एक ऑक्ट्री का उपयोग करके अंतरिक्ष को विभाजित करते हैं, तो निकायों के बीच तुलना की औसत संख्या कम हो जाती है। यदि सभी वस्तुओं को एक बहुत छोटे क्षेत्र में इकट्ठा करना संभव है (कहते हैं कि यदि आप किसी प्रकार के कण प्रवाह सिमुलेशन कर रहे हैं, जहां कण एक ही क्षेत्र में इकट्ठा हो सकते हैं) तो O (N ^ 2) अभी भी हो सकता है सिमुलेशन में अंक (जिस बिंदु पर आप मंदी देखेंगे)।

तो, O (N ^ 2) का पूरा बिंदु वहाँ है क्योंकि प्रत्येक शरीर की प्रकृति दृश्य में प्रत्येक दूसरे शरीर की जाँच कर रही है। यह सिर्फ गणना की प्रकृति है। हालांकि बहुत सी चीजें इसे सस्ता बनाने में मदद कर सकती हैं। यहां तक ​​कि एक दृश्य ग्राफ ( केवल उसी कमरे में वस्तुओं के बीच का पता लगाना ), टकराव की गणना की संख्या को काफी कम कर देगा, लेकिन यह अभी भी O (M ^ 2) होगा (जहां M कमरे में वस्तुओं की संख्या है) टक्कर के खिलाफ पता लगाया जा सकता है)। गोलाकार बाउंडिंग वॉल्यूम प्रारंभिक जांच को बहुत तेज ( if( distance( myCenter, hisCenter ) > (myRadius+hisRadius) ) then MISS) बनाते हैं , इसलिए भले ही टकराव का पता लगाने वाला ओ (एन ^ 2) हो, बाउंडिंग क्षेत्र संगणना बहुत तेजी से होने की संभावना है।

Comments

एक संदर्भ के रूप में ब्रूट फोर्स की जाँच करने की कोई आवश्यकता नहीं है: चतुर एल्गोरिदम की परवाह किए बिना, एन ऑब्जेक्ट्स अन्य सभी वस्तुओं के साथ टकरा सकते हैं, जिससे ओ (एन ^ 2) टकराव की आवश्यकता होती है जो ओ (एन ^ 2) को संसाधित करने की आवश्यकता होती है। कम एल्गोरिदम केवल तभी बेहतर कर सकते हैं जब कम टकराव हो।

— लोरेंजो गट्टी