logo

רצף משנה ממוין בגודל 3 בזמן ליניארי תוך שימוש במרחב קבוע

בהינתן מערך המשימה היא למצוא שלושה אלמנטים של מערך זה כך שהם יהיו בצורה ממוינת, כלומר עבור כל שלושה אלמנטים a[i] a[j] ו-a[k] הם עוקבים אחר הקשר הזה: א[i]< a[j] < a[k] אֵיפֹה אֲנִי< j < k . יש לפתור בעיה זו באמצעות מרחב קבוע או ללא מקום נוסף.

בעיה זו נפתרה כבר בזמן ליניארי באמצעות מרחב ליניארי: מצא תת-רצף ממוין בגודל 3 בזמן ליניארי

דוגמאות:  



  Input:   arr[] = {12 11 10 5 2 6 30}   Output:   5 6 30 or 2 6 30   Explanation:   Answer is 5 6 30 because 5 < 6 < 30 and they occur in this sequence in the array.   Input:   arr[] = {5 7 4 8}   Output:   5 7 8   Explanation:   Answer is 5 7 8 because 5 < 7 < 8 and they occur in the same sequence in the array 

פִּתָרוֹן: המטרה היא למצוא שלושה אלמנטים א ב ו-ג כזה ש א< b < c והאלמנטים חייבים להתרחש באותו רצף במערך.

גִישָׁה: הבעיה עוסקת במציאת שלושה אלמנטים a b c שבהם a< b < c and they must appear in the same order as in the array. So the intuition at any step must be followed as such. One of the variable (קָטָן) צריך לאחסן את האלמנט הקטן ביותר של המערך ואת המשתנה השני גָדוֹל יוקצה ערך כאשר כבר קיים ערך קטן יותר ב- (קָטָן) מִשְׁתַנֶה. זה יוביל ליצירת זוג של שני משתנים שיהוו את שני האלמנטים הראשונים של הרצף הנדרש. באופן דומה אם ניתן למצוא ערך אחר במערך המוקצה כאשר שני המשתנים הראשונים כבר מוקצים ויש להם ערך קטן יותר מהאלמנט הנוכחי, החיפוש אחר הערך השלישי יהיה מושלם. זה משלים את הטריפלטה a b ו-c כך שא< b < c in similar sequence to the array.

אַלגוֹרִיתְם  

  1. צור שלושה משתנים קָטָן - מאחסן את האלמנט הקטן ביותר גָדוֹל - מאחסן את האלמנט השני של הרצף אֲנִי - מונה לולאות
  2. נע לאורך מערך הקלט מההתחלה ועד הסוף.
  3. אם האלמנט הנוכחי קטן או שווה למשתנה קָטָן עדכן את המשתנה.
  4. אחרת אם האלמנט הנוכחי קטן או שווה למשתנה גָדוֹל עדכן את המשתנה. אז הנה אנחנו מקבלים זוג (קטן גדול) ברגע זה איפה קָטָן< large והם מתרחשים ברצף הנדרש.
  5. אחרת אם שני המקרים הקודמים לא מצליחים להתאים, יש לשבור את הלולאה מכיוון שיש לנו זוג שבו האלמנט הנוכחי גדול משני המשתנים קָטָן ו גָדוֹל . אחסן את המדד במשתנה אֲנִי .
  6. אם לא נתקלו בהצהרת הפסקה אז מובטח שלא קיימת שלישייה כזו.
  7. אחרת יש שלישיה עונה על הקריטריונים אבל המשתנה קָטָן אולי עודכן לערך קטן יותר.
  8. אז חצו את המערך מההתחלה לאינדקס i.
  9. הקצה מחדש את המשתנה קָטָן לכל אלמנט פחות מ גָדוֹל מובטח שקיים אחד כזה.
  10. הדפס את הערכים קָטָן גָדוֹל ואלמנט המערך

יישום :

C++
// C/C++ program to find a sorted sub-sequence of // size 3 using constant space #include    using namespace std; // A function to fund a sorted sub-sequence of size 3 void find3Numbers(int arr[] int n) {  // Initializing small and large(second smaller)  // by INT_MAX  int small = INT_MAX large = INT_MAX;  int i;  for (i = 0; i < n; i++)  {  // Update small for smallest value of array  if (arr[i] <= small)  small = arr[i];  // Update large for second smallest value of  // array after occurrence of small  else if (arr[i] <= large)  large = arr[i];  // If we reach here we found 3 numbers in  // increasing order : small large and arr[i]  else  break;  }  if (i == n)  {  printf('No such triplet found');  return;  }  // last and second last will be same but first  // element can be updated retrieving first element  // by looping upto i  for (int j = 0; j <= i; j++)  {  if (arr[j] < large)  {  small = arr[j];  break;  }  }  printf('%d %d %d' small large arr[i]);  return; } // Driver program to test above function int main() {  int arr[] = {5 7 4 8};  int n = sizeof(arr)/sizeof(arr[0]);  find3Numbers(arr n);  return 0; } 
Java
// Java program to find a sorted subsequence of // size 3 using constant space class GFG {  // A function to fund a sorted subsequence of size 3  static void find3Numbers(int arr[] int n)  {  // Initializing small and large(second smaller)  // by INT_MAX  int small = +2147483647 large = +2147483647;  int i;  for (i = 0; i < n; i++)  {  // Update small for smallest value of array  if (arr[i] <= small)  small = arr[i];    // Update large for second smallest value of  // array after occurrence of small  else if (arr[i] <= large)  large = arr[i];    // If we reach here we found 3 numbers in  // increasing order : small large and arr[i]  else  break;  }    if (i == n)  {  System.out.print('No such triplet found');  return;  }    // last and second last will be same but first  // element can be updated retrieving first element  // by looping upto i  for (int j = 0; j <= i; j++)  {  if (arr[j] < large)  {  small = arr[j];  break;  }  }    System.out.print(small+' '+large+' '+arr[i]);  return;  }    // Driver program  public static void main(String arg[])  {  int arr[] = {5 7 4 8};  int n = arr.length;  find3Numbers(arr n);  } } // This code is contributed by Anant Agarwal. 
Python3
# Python3 program to find a sorted subsequence  # of size 3 using constant space # Function to fund a sorted subsequence of size 3 def find3Numbers(arr n): # Initializing small and large(second smaller) # by INT_MAX small = +2147483647 large = +2147483647 for i in range(n): # Update small for smallest value of array if (arr[i] <= small): small = arr[i] # Update large for second smallest value of # array after occurrence of small elif (arr[i] <= large): large = arr[i] # If we reach here we found 3 numbers in # increasing order : small large and arr[i] else: break if (i == n): print('No such triplet found') return # last and second last will be same but # first element can be updated retrieving  # first element by looping upto i for j in range(i + 1): if (arr[j] < large): small = arr[j] break print(small' 'large' 'arr[i]) return # Driver program arr= [5 7 4 8] n = len(arr) find3Numbers(arr n) # This code is contributed by Anant Agarwal. 
C#
// C# program to find a sorted sub-sequence of // size 3 using constant space using System; class GFG {    // A function to fund a sorted sub-sequence  // of size 3  static void find3Numbers(int []arr int n)  {    // Initializing small and large(second smaller)  // by INT_MAX  int small = +2147483647 large = +2147483647;  int i;  for (i = 0; i < n; i++)  {    // Update small for smallest value of array  if (arr[i] <= small)  small = arr[i];    // Update large for second smallest value of  // array after occurrence of small  else if (arr[i] <= large)  large = arr[i];    // If we reach here we found 3 numbers in  // increasing order : small large and arr[i]  else  break;  }    if (i == n)  {  Console.Write('No such triplet found');  return;  }    // last and second last will be same but first  // element can be updated retrieving first element  // by looping upto i  for (int j = 0; j <= i; j++)  {  if (arr[j] < large)  {  small = arr[j];  break;  }  }    Console.Write(small + ' ' + large + ' ' + arr[i]);  return;  }    // Driver program  public static void Main()  {  int []arr = {5 7 4 8};  int n = arr.Length;  find3Numbers(arr n);  } } <br> // This code is contributed by nitin mittal 
PHP
 // PHP program to find a sorted  // subsequence of size 3 using  // constant space // A function to fund a sorted // subsequence of size 3 function find3Numbers($arr $n) { // Initializing small and  // large(second smaller) // by INT_MAX $small = PHP_INT_MAX; $large = PHP_INT_MAX; $i; for($i = 0; $i < $n; $i++) { // Update small for smallest // value of array if ($arr[$i] <= $small) $small = $arr[$i]; // Update large for second // smallest value of after  // occurrence of small else if ($arr[$i] <= $large) $large = $arr[$i]; // If we reach here we  // found 3 numbers in // increasing order :  // small large and arr[i] else break; } if ($i == $n) { echo 'No such triplet found'; return; } // last and second last will // be same but first // element can be updated  // retrieving first element // by looping upto i for($j = 0; $j <= $i; $j++) { if ($arr[$j] < $large) { $small = $arr[$j]; break; } } echo $small' ' $large' ' $arr[$i]; return; } // Driver Code $arr = array(5 7 4 8); $n = count($arr); find3Numbers($arr $n); // This code is contributed by anuj_67. ?> 
JavaScript
<script>  // JavaScript program to find a  // sorted sub-sequence of  // size 3 using constant space    // A function to fund a sorted sub-sequence  // of size 3  function find3Numbers(arr n)  {    // Initializing small and large(second smaller)  // by INT_MAX  let small = +2147483647 large = +2147483647;  let i;  for (i = 0; i < n; i++)  {    // Update small for smallest value of array  if (arr[i] <= small)  small = arr[i];    // Update large for second smallest value of  // array after occurrence of small  else if (arr[i] <= large)  large = arr[i];    // If we reach here we found 3 numbers in  // increasing order : small large and arr[i]  else  break;  }    if (i == n)  {  document.write('No such triplet found');  return;  }    // last and second last will be same but first  // element can be updated retrieving first element  // by looping upto i  for (let j = 0; j <= i; j++)  {  if (arr[j] < large)  {  small = arr[j];  break;  }  }    document.write(small + ' ' + large + ' ' + arr[i]);  return;  }    let arr = [5 7 4 8];  let n = arr.length;  find3Numbers(arr n);   </script> 

תְפוּקָה
5 7 8

ניתוח מורכבות:  

    מורכבות זמן: O(n). 
    מכיוון שהמערך עובר רק פי שניים, מורכבות הזמן היא O(2*n) ששווה ל עַל) .מורכבות החלל: O(1). 
    מכיוון שרק שלושה אלמנטים מאוחסנים, מורכבות החלל קבועה או O(1) .