Gegeben sei ein Array mit n unterschiedlichen Elementen. Ermitteln Sie das Maximum des Produkts aus dem Minimum zweier Zahlen im Array und der absoluten Differenz ihrer Positionen, d. h. ermitteln Sie den Maximalwert von abs(i - j) * min(arr[i] arr[j]), wobei i und j zwischen 0 und n-1 variieren.
Was ist in Python?
Beispiele:
Input : arr[] = {3 2 1 4} Output: 9 // arr[0] = 3 and arr[3] = 4 minimum of them is 3 and // absolute difference between their position is // abs(0-3) = 3. So product is 3*3 = 9 Input : arr[] = {8 1 9 4} Output: 16 // arr[0] = 8 and arr[2] = 9 minimum of them is 8 and // absolute difference between their position is // abs(0-2) = 2. So product is 8*2 = 16 Recommended Practice Finden Sie den Maximalwert Probieren Sie es aus! A einfache Lösung Dieses Problem besteht darin, jedes Element einzeln zu nehmen und dieses Element mit den Elementen rechts davon zu vergleichen. Berechnen Sie dann das Produkt aus dem Minimum davon und der absoluten Differenz zwischen ihren Indizes und maximieren Sie das Ergebnis. Die Zeitkomplexität für diesen Ansatz beträgt O(n^2).
Ein effiziente Lösung um das Problem in linearer Zeitkomplexität zu lösen. Wir nehmen zwei Iteratoren Links=0 Und Rechts=n-1 Vergleichen Sie die Elemente arr[Left] und arr[right].
left = 0 right = n-1 maxProduct = -INF While (left < right) If arr[Left] < arr[right] currProduct = arr[Left]*(right-Left) Left++ . If arr[right] < arr[Left] currProduct = arr[Right]*(Right-Left) Right-- . maxProduct = max(maxProduct currProduct)
Nachfolgend finden Sie die Umsetzung der obigen Idee.
C++// C++ implementation of code #include
// Java implementation of code import java.util.*; class GFG { // Function to calculate maximum value of // abs(i - j) * min(arr[i] arr[j]) in arr[] static int Maximum_Product(int arr[] int n) { // Initialize result int maxProduct = Integer.MIN_VALUE; // product of current pair int currProduct; // loop until they meet with each other int Left = 0 right = n - 1; while (Left < right) { if (arr[Left] < arr[right]) { currProduct = arr[Left] * (right - Left); Left++; } // arr[right] is smaller else { currProduct = arr[right] * (right - Left); right--; } // maximizing the product maxProduct = Math.max(maxProduct currProduct); } return maxProduct; } // Driver code public static void main(String[] args) { int arr[] = {8 1 9 4}; int n = arr.length; System.out.print(Maximum_Product(arr n)); } } // This code is contributed by Anant Agarwal.
# Python implementation of code # Function to calculate # maximum value of # abs(i - j) * min(arr[i] # arr[j]) in arr[] def Maximum_Product(arrn): # Initialize result maxProduct = -2147483648 # product of current pair currProduct=0 # loop until they meet with each other Left = 0 right = n-1 while (Left < right): if (arr[Left] < arr[right]): currProduct = arr[Left]*(right-Left) Left+=1 else: # arr[right] is smaller currProduct = arr[right]*(right-Left) right-=1 # maximizing the product maxProduct = max(maxProduct currProduct) return maxProduct # Driver code arr = [8 1 9 4] n = len(arr) print(Maximum_Product(arrn)) # This code is contributed # by Anant Agarwal.
// C# implementation of code using System; class GFG { // Function to calculate maximum // value of abs(i - j) * min(arr[i] // arr[j]) in arr[] static int Maximum_Product(int []arr int n) { // Initialize result int maxProduct = int.MinValue; // product of current pair int currProduct; // loop until they meet // with each other int Left = 0 right = n - 1; while (Left < right) { if (arr[Left] < arr[right]) { currProduct = arr[Left] * (right - Left); Left++; } // arr[right] is smaller else { currProduct = arr[right] * (right - Left); right--; } // maximizing the product maxProduct = Math.Max(maxProduct currProduct); } return maxProduct; } // Driver code public static void Main() { int []arr = {8 1 9 4}; int n = arr.Length; Console.Write(Maximum_Product(arr n)); } } // This code is contributed by nitin mittal.
// PHP implementation of code // Function to calculate // maximum value of // abs(i - j) * min(arr[i] // arr[j]) in arr[] function Maximum_Product($arr $n) { $INT_MIN = 0; // Initialize result $maxProduct = $INT_MIN; // product of current pair $currProduct; // loop until they meet // with each other $Left = 0; $right = $n - 1; while ($Left < $right) { if ($arr[$Left] < $arr[$right]) { $currProduct = $arr[$Left] * ($right - $Left); $Left++; } // arr[right] is smaller else { $currProduct = $arr[$right] * ($right - $Left); $right--; } // maximizing the product $maxProduct = max($maxProduct $currProduct); } return $maxProduct; } // Driver Code $arr = array(8 1 9 4); $n = sizeof($arr) / sizeof($arr[0]); echo Maximum_Product($arr $n); // This code is contributed // by nitin mittal. ?> <script> // Javascript implementation of code // Function to calculate // maximum value of // abs(i - j) * min(arr[i] // arr[j]) in arr[] function Maximum_Product(arr n) { let INT_MIN = 0; // Initialize result let maxProduct = INT_MIN; // Product of current pair let currProduct; // Loop until they meet // with each other let Left = 0 right = n - 1; while (Left < right) { if (arr[Left] < arr[right]) { currProduct = arr[Left] * (right - Left); Left++; } // arr[right] is smaller else { currProduct = arr[right] * (right - Left); right--; } // Maximizing the product maxProduct = Math.max(maxProduct currProduct); } return maxProduct; } // Driver Code let arr = new Array(8 1 9 4); let n = arr.length; document.write(Maximum_Product(arr n)); // This code is contributed by Saurabh Jaiswal </script>
Ausgabe
16
Zeitkomplexität: O(N log N) Hier ist N die Länge des Arrays.
Raumkomplexität: O(1) da kein zusätzlicher Platz genutzt wird.
Wie funktioniert das?
Wichtig ist zu zeigen, dass wir im obigen linearen Algorithmus kein potenzielles Paar übersehen, d. h. wir müssen zeigen, dass die Ausführung von links++ oder rechts nicht zu einem Fall führt, in dem wir einen höheren Wert von maxProduct erhalten hätten.
Bitte beachten Sie, dass wir immer mit (rechts - links) multiplizieren.
- Wenn arr[links]< arr[right] then smaller values of Rechts für current left sind nutzlos, da sie keinen höheren Wert von maxProduct erzeugen können (weil wir mit arr[left] mit (right - left) multiplizieren). Was wäre, wenn arr[left] größer wäre als eines der Elemente auf der linken Seite? In diesem Fall muss mit dem aktuellen Recht ein besseres Paar für dieses Element gefunden worden sein. Daher können wir sicher nach links erhöhen, ohne ein besseres Paar mit der aktuellen Linken zu verpassen.
- Ähnliche Argumente gelten, wenn arr[right]< arr[left].