पायथन में बम लगाए बिना एक आयताकार क्षेत्र में एक निरंतर पथ खोजने का कार्यक्रम

मान लीजिए हमें एक सरणी चटाई दी गई है जहां तत्व इस रूप के हैं [p, q, r] जहां p, q ज्यामितीय निर्देशांक हैं और r त्रिज्या मान है। सरणी में आइटम दिए गए चौड़ाई w के आयताकार क्षेत्र में बम के स्थान हैं। आयत अपरिमित रूप से लंबी है और x निर्देशांक x =0 से x =w तक सीमित है। बम की स्थिति में r मान एक बम की सुरक्षा त्रिज्या को दर्शाता है, जिसका अर्थ है कि बम की त्रिज्या से कम कुछ भी इसे संलग्न करेगा। तो, हमें क्या करना है एक निरंतर पथ बनाना है जो प्रत्येक बम के नीचे से शुरू होता है और प्रत्येक बम के ऊपर समाप्त होता है, उनमें से किसी एक को शामिल किए बिना। यदि हम इस रेखा को खींच सकते हैं तो हम ट्रू प्रिंट करेंगे, अन्यथा हम गलत प्रिंट करेंगे।

तो, अगर इनपुट चटाई की तरह है =

0	1	2
3	2	1
2	1	1

, डब्ल्यू =4; तो आउटपुट गलत होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

एक फ़ंक्शन परिभाषित करें insec() । इसमें p, q
- x1 :=p[1], x2 :=p[2]
- y2:=q[1], y4:=q[2]
- r1 :=p[3], r2 :=q[3]
- d :=(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
- दिसंबर :=(r1 + r2) *(r1 + r2)
- सही लौटें अगर d <=dec, अन्यथा गलत लौटें
x निर्देशांक मानों के आधार पर मैट्रिक्स को क्रमबद्ध करें
अस्थायी:=एक नई सूची
अगर चटाई[0][0] - चटाई[0][2]> 0, तो
- सही लौटें
चटाई में प्रत्येक p, q, r के लिए करें
- min_wid :=p - r
- max_wid :=p + r
- यदि अस्थायी का आकार 0 के समान है, तो
  - अस्थायी के अंत में (p + r, p, q, r, p - r, p + r) वाली सूची जोड़ें
- अन्यथा,
  - mx :=अधिकतम (अस्थायी में वह स्थिति जहां सूची [p - r, -p, q, r, 0, 0] को क्रमबद्ध क्रम को बनाए रखते हुए डाला जा सकता है -1), 0
  - in_list :=तत्वों वाली एक नई सूची (p + r, p, q, r, p - r, p + r)
  - मैं के लिए एमएक्स से अस्थायी के आकार की सीमा में, करते हैं
    - अगर insec(temp[i], in_list) सही है, तो
      - max_wid =अधिकतम (max_wid, temp[i, -1])
    - min_wid =न्यूनतम (min_wid, temp[i, -2])
  - in_list का दूसरा अंतिम तत्व :=min_wid
  - in_list का last_element :=max_wid
  - सॉर्ट किए गए क्रम को बनाए रखते हुए अस्थायी में in_list डालें
- अगर min_wid <=0 और max_wid>=w, तो
  - झूठी वापसी
सही लौटें

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

from bisect import bisect_left, insort
def solve(mat, w):
   mat.sort(key=lambda i: i[0] - i[2])
   temp = []
   if mat[0][0] - mat[0][2] > 0:
      return True
   for p, q, r in mat:
      min_wid, max_wid = p - r, p + r
      if len(temp) == 0:
         temp.append([p + r, p, q, r, p - r, p + r])
      else:
         mx = max(bisect_left(temp, [p - r, -p, q, r, 0, 0]) - 1, 0)

         in_list = [p + r, p, q, r, p - r, p + r]
         for i in range(mx, len(temp)):
             if insec(temp[i], in_list):
               max_wid = max(max_wid, temp[i][-1])
               min_wid = min(min_wid, temp[i][-2])
         in_list[-2] = min_wid
         in_list[-1] = max_wid
         insort(temp, in_list)
      if min_wid <= 0 and max_wid >= w:
         return False
   return True

def insec(p, q):
   x1, y1, x2, y2 = p[1], p[2], q[1], q[2]
   r1, r2 = p[3], q[3]
   d = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
   dec = (r1 + r2) * (r1 + r2)
   return d <= dec

print(solve([[0, 1, 2],[3, 2, 1], [2, 1, 1]], 4))

इनपुट

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

आउटपुट

False