सी ++ में सबसे लंबे बिटोनिक बाद की लंबाई खोजने का कार्यक्रम

मान लीजिए हमारे पास संख्याओं की एक सूची है। हमें सबसे लंबे बिटोनिक बाद की लंबाई का पता लगाना है। असवे गाँठ एक अनुक्रम को बिटोनिक कहा जाता है यदि यह सख्ती से बढ़ रहा है और फिर सख्ती से घट रहा है। सख्ती से बढ़ता क्रम बिटोनिक है। या सख्ती से घटने वाला क्रम बिटोनिक भी है।

इसलिए, यदि इनपुट अंकों की तरह है =[0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15], अनुक्रम का आकार 16., तो आउटपुट 7 होगा।

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

• बढ़ते हुए सबसेक:=दिए गए सरणी आकार की नई सरणी, और 1 से भरें

• इनिशियलाइज़ i :=1 के लिए, जब i <साइज़, अपडेट (i 1 से बढ़ाएँ), करें -

  • इनिशियलाइज़ j :=0 के लिए, जब j

    • अगर arr[i]> arr[j] और बढ़ते हुएSubSeq[i] <बढ़तेSubSeq[j] + 1, तो -

      • बढ़तीसबसेक[i] :=बढ़ती हुईसबसेक[जे] + 1

    • *घटते SubSeq :=दिए गए सरणी आकार की नई सरणी, और 1 से भरें

  • इनिशियलाइज़ करने के लिए i :=size - 2, जब i>=0, अपडेट करें (i से 1 घटाएं), करें -

    • इनिशियलाइज़ j :=size-1 के लिए, जब j> i, अपडेट करें (j को 1 से घटाएं), −

      करें

      • अगर arr[i]> arr[j] और घटते SubSeq[i] <घटतेSubSeq[j] + 1, तो -

        • घटतेसुबसेक[i] :=घटतेसुबसेक[जे] + 1

      • अधिकतम :=बढ़ानासबसेक[0] + घटतेसबसेक[0] - 1

    • इनिशियलाइज़ करने के लिए i :=1, जब i <आकार, अपडेट (i से 1 की वृद्धि), करें -

      • अगर बढ़ते हुएSubSeq[i] + घटतेSubSeq[i] - 1> अधिकतम, तो:

        • अधिकतम :=बढ़ानासबसेक[i] + घटते सबसेक[i] - 1

      • अधिकतम वापसी

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

उदाहरण

#include<iostream>
using namespace std;
int longBitonicSub( int arr[], int size ) {
   int *increasingSubSeq = new int[size];
   for (int i = 0; i < size; i++)
      increasingSubSeq[i] = 1;
   for (int i = 1; i < size; i++)
      for (int j = 0; j < i; j++)
         if (arr[i] > arr[j] && increasingSubSeq[i] <
         increasingSubSeq[j] + 1)
         increasingSubSeq[i] = increasingSubSeq[j] + 1;
   int *decreasingSubSeq = new int [size];
   for (int i = 0; i < size; i++)
      decreasingSubSeq[i] = 1;
   for (int i = size-2; i >= 0; i--)
      for (int j = size-1; j > i; j--)
         if (arr[i] > arr[j] && decreasingSubSeq[i] < decreasingSubSeq[j] + 1)
decreasingSubSeq[i] = decreasingSubSeq[j] + 1;
   int max = increasingSubSeq[0] + decreasingSubSeq[0] - 1;
   for (int i = 1; i < size; i++)
      if (increasingSubSeq[i] + decreasingSubSeq[i] - 1 > max)
         max = increasingSubSeq[i] + decreasingSubSeq[i] - 1;
   return max;
}
int main() {
   int arr[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
   int n = 16;
   cout << longBitonicSub(arr, n);
}

इनपुट

[0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15], 16

आउटपुट

7