मान लीजिए हमारे पास संख्याओं की एक सूची है जिसे अंक और दो मान, आकार और k कहा जाता है। अब मान लीजिए कि एक ऑपरेशन है जहाँ हम लंबाई के आकार का एक सन्निहित सबलिस्ट लेते हैं और प्रत्येक तत्व को एक-एक करके बढ़ाते हैं। हम इस ऑपरेशन को k बार कर सकते हैं, हमें अंकों में अधिकतम संभव न्यूनतम मान ज्ञात करना होगा।
इसलिए, यदि इनपुट संख्या =[2, 5, 2, 2, 7], आकार =3, के =2 की तरह है, तो आउटपुट 3 होगा, क्योंकि हम [2, 5, 2] प्राप्त करने के लिए [2, 5, 2] बढ़ा सकते हैं। 3, 6, 3, 2, 7] और फिर वृद्धि [6, 3, 2] पाने के लिए [3, 7, 4, 3, 7], न्यूनतम 3 है
इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -
- एक फ़ंक्शन को संभव () परिभाषित करें। यह लक्ष्य लेगा
- ईवेंट :=आकार N की एक सूची, और 0 से भरें
- चाल :=0, s :=0
- मैं के लिए 0 से N की सीमा में, करते हैं
- s :=s + इवेंट्स[i]
- डेल्टा:=लक्ष्य -(A[i] + s)
- यदि डेल्टा> 0, तो
- चाल :=चाल + डेल्टा
- s :=s + डेल्टा
- यदि मैं + आकार <एन, तो
- ईवेंट्स[i + size] :=इवेंट्स[i + size] - डेल्टा
- चलने पर सही लौटें <=K
- मुख्य विधि से, निम्न कार्य करें
- N :=A का आकार
- बाएं:=0, दाएं:=10^10
- बाएं <दाएं, करते हैं
- मध्य :=(बाएं + दाएं + 1) / 2
- यदि संभव हो (मध्य), तो
- बाएं:=मध्य
- अन्यथा,
- दाएं:=मध्य -1
- बाएं लौटें
आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -
उदाहरण
class Solution: def solve(self, A, size, K): N = len(A) def possible(target): events = [0] * N moves = s = 0 for i in range(N): s += events[i] delta = target - (A[i] + s) if delta > 0: moves += delta s += delta if i + size < N: events[i + size] -= delta return moves <= K left, right = 0, 10 ** 10 while left < right: mid = (left + right + 1)//2 if possible(mid): left = mid else: right = mid - 1 return left ob = Solution() nums = [2, 5, 2, 2, 7] size = 3 k = 2 print(ob.solve(nums, size, k))
इनपुट
[2, 5, 2, 2, 7], 3, 2
आउटपुट
3