हमें 0 और N-1 की रेंज में स्थित तत्वों वाली N संख्याओं की एक सरणी दी गई है। तत्व असॉर्टेड हैं। लक्ष्य सरणी के उन अधिकतम पार्टीशन की संख्या ढूंढना है जिन्हें व्यक्तिगत रूप से क्रमबद्ध किया जा सकता है और फिर संयोजित करके पूरी N लंबाई की क्रमबद्ध सरणी बनाई जा सकती है।
प्रत्येक पार्टीशन को इस तरह चुना जाता है कि उसके तत्व असॉर्टेड हों। 0 और N-1 के बीच की N संख्याओं के लिए, क्रमबद्ध तत्व इंडेक्स के बराबर मान पर होते हैं। Arr[i] = i।
हम इसे प्रत्येक तत्व की तुलना उसके बाएं अब तक मिले अधिकतम मान से करके हल करेंगे। जब अधिकतम की सही स्थिति पर पहुंचते हैं, (अधिकतम == i)। इसके बाएं सभी तत्व कम हैं इसलिए एक अलग पार्टीशन बना सकते हैं। इसके दाएं सभी बड़े हैं। अब शेष दाएं तत्वों के लिए भी यही प्रक्रिया करें और उन्हें पार्टीशन में विभाजित करें।
आइए उदाहरणों से समझते हैं।
इनपुट - Arr[]={ 0,3,2,1,4,5 }
आउटपुट - अधिकतम पार्टीशन की संख्या: 3
व्याख्या - 0 से शुरू करते हैं, मान लें max=0 Arr[0]
इंडेक्स 0 और 3 के बीच। 3 अधिकतम है। जब इंडेक्स i=3 पर पहुंचते हैं (max==i)। तो पहला पार्टीशन है [0,3,2,1]
इंडेक्स 4 के लिए, अधिकतम 4 है। इंडेक्स i=4 (max==i)। तो दूसरा पार्टीशन है [4]
इंडेक्स 5 के लिए, अधिकतम 5 है। इंडेक्स i=5 (max==i)। तो तीसरा पार्टीशन है [5]
कुल 3 पार्टीशन [0,3,2,1][4][5]। प्रत्येक को क्रमबद्ध करें और संयोजित करें।
इनपुट - Arr[]={ 5,4,3,2,1,0 }
आउटपुट - अधिकतम पार्टीशन की संख्या: 1
व्याख्या - 0 से शुरू करते हैं, मान लें max=0 Arr[0]
इंडेक्स 0 और 5 के बीच। 5 अधिकतम है। जब इंडेक्स i=5 पर पहुंचते हैं (max==i)। तो केवल पार्टीशन है [5,4,3,2,1,0]
नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण
हम 0 से N की रेंज में संख्याओं से आरंभ एक पूर्णांक सरणी Num[] लेते हैं।
फंक्शन partitions(int arr[], int n) एक सरणी और उसकी लंबाई को पैरामीटर के रूप में लेता है और उन अधिकतम पार्टीशन की गिनती लौटाता है जिन्हें व्यक्तिगत रूप से क्रमबद्ध करके पूरी सरणी को क्रमबद्ध किया जा सकता है।
प्रारंभिक पार्टीशन काउंट 0 है। प्रारंभिक अधिकतम मान maxx में arr[0] के रूप में है।
बाएं से सभी तत्वों के लिए शुरू करते हैं। जांचते हैं कि क्या यह maxx से बड़ा है।
यदि arr[i]>maxx सही है। maxx को अपडेट करते हैं।
यदि वर्तमान maxx और इंडेक्स समान हैं। (maxx==i) तो i तक के सभी तत्व एक पार्टीशन का हिस्सा हैं। काउंट बढ़ाते हैं।
दाएं के शेष तत्वों के लिए अंत तक ऐसा करते हैं।
परिणाम को काउंट के रूप में लौटाते हैं।
उदाहरण
#include <bits/stdc++.h> using namespace std; int partitions(int arr[], int n){ int count = 0; int maxx = arr[0]; for (int i = 0; i < n; ++i) { if(arr[i] > maxx) maxx=arr[i]; if (maxx == i) count++; } return count; } int main(){ int Num[] = { 2,1,0,4,5,3 }; int len = 6; cout <<"व्यक्तिगत रूप से क्रमबद्ध किए जा सकने वाले अधिकतम पार्टीशन: "<<partitions(Num, len); return 0; } आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा -
व्यक्तिगत रूप से क्रमबद्ध किए जा सकने वाले अधिकतम पार्टीशन: 18