Größte Summe zusammenhängender zunehmender Subarrays
Probieren Sie es bei GfG Practice aus 
#practiceLinkDiv { display: none !important; }
#practiceLinkDiv { display: none !important; } Gegeben sei ein Array von n positiv unterschiedlichen ganzen Zahlen. Das Problem besteht darin, die größte Summe zusammenhängender zunehmender Subarrays in O(n)-Zeitkomplexität zu finden.
Beispiele:
Input : arr[] = {2 1 4 7 3 6}
Output : 12
Contiguous Increasing subarray {1 4 7} = 12
Input : arr[] = {38 7 8 10 12}
Output : 38
Recommended Practice Gieriger Fuchs Probieren Sie es aus!A einfache Lösung ist zu Generieren Sie alle Subarrays und berechnen Sie ihre Summen. Geben Sie schließlich das Subarray mit der maximalen Summe zurück. Die zeitliche Komplexität dieser Lösung beträgt O(n 2 ).
Ein effiziente Lösung basiert auf der Tatsache, dass alle Elemente positiv sind. Daher betrachten wir die am längsten wachsenden Subarrays und vergleichen ihre Summen. Zunehmende Subarrays können sich nicht überlappen, sodass unsere Zeitkomplexität O(n) wird.
Algorithmus:
Let arr be the array of size n
Let result be the required sum
int largestSum(arr n)
result = INT_MIN // Initialize result
i = 0
while i < n
// Find sum of longest increasing subarray
// starting with i
curr_sum = arr[i];
while i+1 < n && arr[i] < arr[i+1]
curr_sum += arr[i+1];
i++;
// If current sum is greater than current
// result.
if result < curr_sum
result = curr_sum;
i++;
return result
Nachfolgend finden Sie die Implementierung des obigen Algorithmus.
C++Java// C++ implementation of largest sum // contiguous increasing subarray #includeusing namespace std ; // Returns sum of longest // increasing subarray. int largestSum ( int arr [] int n ) { // Initialize result int result = INT_MIN ; // Note that i is incremented // by inner loop also so overall // time complexity is O(n) for ( int i = 0 ; i < n ; i ++ ) { // Find sum of longest // increasing subarray // starting from arr[i] int curr_sum = arr [ i ]; while ( i + 1 < n && arr [ i + 1 ] > arr [ i ]) { curr_sum += arr [ i + 1 ]; i ++ ; } // Update result if required if ( curr_sum > result ) result = curr_sum ; } // required largest sum return result ; } // Driver Code int main () { int arr [] = { 1 1 4 7 3 6 }; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); cout < < 'Largest sum = ' < < largestSum ( arr n ); return 0 ; } Python3// Java implementation of largest sum // contiguous increasing subarray class GFG { // Returns sum of longest // increasing subarray. static int largestSum ( int arr [] int n ) { // Initialize result int result = - 9999999 ; // Note that i is incremented // by inner loop also so overall // time complexity is O(n) for ( int i = 0 ; i < n ; i ++ ) { // Find sum of longest // increasing subarray // starting from arr[i] int curr_sum = arr [ i ] ; while ( i + 1 < n && arr [ i + 1 ] > arr [ i ] ) { curr_sum += arr [ i + 1 ] ; i ++ ; } // Update result if required if ( curr_sum > result ) result = curr_sum ; } // required largest sum return result ; } // Driver Code public static void main ( String [] args ) { int arr [] = { 1 1 4 7 3 6 }; int n = arr . length ; System . out . println ( 'Largest sum = ' + largestSum ( arr n )); } }C## Python3 implementation of largest # sum contiguous increasing subarray # Returns sum of longest # increasing subarray. def largestSum ( arr n ): # Initialize result result = - 2147483648 # Note that i is incremented # by inner loop also so overall # time complexity is O(n) for i in range ( n ): # Find sum of longest increasing # subarray starting from arr[i] curr_sum = arr [ i ] while ( i + 1 < n and arr [ i + 1 ] > arr [ i ]): curr_sum += arr [ i + 1 ] i += 1 # Update result if required if ( curr_sum > result ): result = curr_sum # required largest sum return result # Driver Code arr = [ 1 1 4 7 3 6 ] n = len ( arr ) print ( 'Largest sum = ' largestSum ( arr n )) # This code is contributed by Anant Agarwal.JavaScript// C# implementation of largest sum // contiguous increasing subarray using System ; class GFG { // Returns sum of longest // increasing subarray. static int largestSum ( int [] arr int n ) { // Initialize result int result = - 9999999 ; // Note that i is incremented by // inner loop also so overall // time complexity is O(n) for ( int i = 0 ; i < n ; i ++ ) { // Find sum of longest increasing // subarray starting from arr[i] int curr_sum = arr [ i ]; while ( i + 1 < n && arr [ i + 1 ] > arr [ i ]) { curr_sum += arr [ i + 1 ]; i ++ ; } // Update result if required if ( curr_sum > result ) result = curr_sum ; } // required largest sum return result ; } // Driver code public static void Main () { int [] arr = { 1 1 4 7 3 6 }; int n = arr . Length ; Console . Write ( 'Largest sum = ' + largestSum ( arr n )); } } // This code is contributed // by Nitin Mittal.PHP< script > // Javascript implementation of largest sum // contiguous increasing subarray // Returns sum of longest // increasing subarray. function largestSum ( arr n ) { // Initialize result var result = - 1000000000 ; // Note that i is incremented // by inner loop also so overall // time complexity is O(n) for ( var i = 0 ; i < n ; i ++ ) { // Find sum of longest // increasing subarray // starting from arr[i] var curr_sum = arr [ i ]; while ( i + 1 < n && arr [ i + 1 ] > arr [ i ]) { curr_sum += arr [ i + 1 ]; i ++ ; } // Update result if required if ( curr_sum > result ) result = curr_sum ; } // required largest sum return result ; } // Driver Code var arr = [ 1 1 4 7 3 6 ]; var n = arr . length ; document . write ( 'Largest sum = ' + largestSum ( arr n )); // This code is contributed by itsok. < /script>
AusgabeLargest sum = 12Zeitkomplexität: O(n)
Größte Summe zusammenhängender zunehmender Subarrays Rekursion :
Rekursiver Algorithmus zur Lösung dieses Problems:
Hier ist der Schritt-für-Schritt-Algorithmus des Problems:
- Die Funktion 'größteSum' Nimmt ein Array auf 'arr' und es ist groß 'N'.
- Wenn 'n==1' dann zurück arr[0]th Element.
- Wenn 'n != 1' dann ein rekursiver Aufruf der Funktion 'größteSum' um die größte Summe des Subarrays zu finden 'arr[0...n-1]' ohne das letzte Element 'arr[n-1]' .
- Durch Durchlaufen des Arrays in umgekehrter Reihenfolge, beginnend mit dem vorletzten Element, berechnen Sie die Summe des zunehmenden Subarrays, das bei endet 'arr[n-1]' . Wenn ein Element kleiner als das nächste ist, sollte es zur aktuellen Summe addiert werden. Andernfalls sollte die Schleife unterbrochen werden.
- Geben Sie dann das Maximum der größten Summe zurück, d. h. ' return max(max_sum curr_sum);' .
Hier ist die Implementierung des obigen Algorithmus:
C++C#includeusing namespace std ; // Recursive function to find the largest sum // of contiguous increasing subarray int largestSum ( int arr [] int n ) { // Base case if ( n == 1 ) return arr [ 0 ]; // Recursive call to find the largest sum int max_sum = max ( largestSum ( arr n - 1 ) arr [ n - 1 ]); // Compute the sum of the increasing subarray int curr_sum = arr [ n - 1 ]; for ( int i = n - 2 ; i >= 0 ; i -- ) { if ( arr [ i ] < arr [ i + 1 ]) curr_sum += arr [ i ]; else break ; } // Return the maximum of the largest sum so far // and the sum of the current increasing subarray return max ( max_sum curr_sum ); } // Driver Code int main () { int arr [] = { 1 1 4 7 3 6 }; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); cout < < 'Largest sum = ' < < largestSum ( arr n ); return 0 ; } // This code is contributed by Vaibhav Saroj. Java#include#include // Returns sum of longest increasing subarray int largestSum ( int arr [] int n ) { // Initialize result int result = INT_MIN ; // Note that i is incremented // by inner loop also so overall // time complexity is O(n) for ( int i = 0 ; i < n ; i ++ ) { // Find sum of longest // increasing subarray // starting from arr[i] int curr_sum = arr [ i ]; while ( i + 1 < n && arr [ i + 1 ] > arr [ i ]) { curr_sum += arr [ i + 1 ]; i ++ ; } // Update result if required if ( curr_sum > result ) result = curr_sum ; } // required largest sum return result ; } // Driver code int main () { int arr [] = { 1 1 4 7 3 6 }; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); printf ( 'Largest sum = %d n ' largestSum ( arr n )); return 0 ; } // This code is contributed by Vaibhav Saroj. Python/*package whatever //do not write package name here */ import java.util.* ; public class Main { // Recursive function to find the largest sum // of contiguous increasing subarray public static int largestSum ( int arr [] int n ) { // Base case if ( n == 1 ) return arr [ 0 ] ; // Recursive call to find the largest sum int max_sum = Math . max ( largestSum ( arr n - 1 ) arr [ n - 1 ] ); // Compute the sum of the increasing subarray int curr_sum = arr [ n - 1 ] ; for ( int i = n - 2 ; i >= 0 ; i -- ) { if ( arr [ i ] < arr [ i + 1 ] ) curr_sum += arr [ i ] ; else break ; } // Return the maximum of the largest sum so far // and the sum of the current increasing subarray return Math . max ( max_sum curr_sum ); } // Driver code public static void main ( String [] args ) { int arr [] = { 1 1 4 7 3 6 }; int n = arr . length ; System . out . println ( 'Largest sum = ' + largestSum ( arr n )); } } // This code is contributed by Vaibhav Saroj.C#def largestSum ( arr n ): # Base case if n == 1 : return arr [ 0 ] # Recursive call to find the largest sum max_sum = max ( largestSum ( arr n - 1 ) arr [ n - 1 ]) # Compute the sum of the increasing subarray curr_sum = arr [ n - 1 ] for i in range ( n - 2 - 1 - 1 ): if arr [ i ] < arr [ i + 1 ]: curr_sum += arr [ i ] else : break # Return the maximum of the largest sum so far # and the sum of the current increasing subarray return max ( max_sum curr_sum ) # Driver code arr = [ 1 1 4 7 3 6 ] n = len ( arr ) print ( 'Largest sum =' largestSum ( arr n )) # This code is contributed by Vaibhav Saroj.JavaScript// C# program for above approach using System ; public static class GFG { // Recursive function to find the largest sum // of contiguous increasing subarray public static int largestSum ( int [] arr int n ) { // Base case if ( n == 1 ) return arr [ 0 ]; // Recursive call to find the largest sum int max_sum = Math . Max ( largestSum ( arr n - 1 ) arr [ n - 1 ]); // Compute the sum of the increasing subarray int curr_sum = arr [ n - 1 ]; for ( int i = n - 2 ; i >= 0 ; i -- ) { if ( arr [ i ] < arr [ i + 1 ]) curr_sum += arr [ i ]; else break ; } // Return the maximum of the largest sum so far // and the sum of the current increasing subarray return Math . Max ( max_sum curr_sum ); } // Driver code public static void Main () { int [] arr = { 1 1 4 7 3 6 }; int n = arr . Length ; Console . WriteLine ( 'Largest sum = ' + largestSum ( arr n )); } } // This code is contributed by Utkarsh KumarPHPfunction largestSum ( arr n ) { // Base case if ( n == 1 ) return arr [ 0 ]; // Recursive call to find the largest sum let max_sum = Math . max ( largestSum ( arr n - 1 ) arr [ n - 1 ]); // Compute the sum of the increasing subarray let curr_sum = arr [ n - 1 ]; for ( let i = n - 2 ; i >= 0 ; i -- ) { if ( arr [ i ] < arr [ i + 1 ]) curr_sum += arr [ i ]; else break ; } // Return the maximum of the largest sum so far // and the sum of the current increasing subarray return Math . max ( max_sum curr_sum ); } // Driver Code let arr = [ 1 1 4 7 3 6 ]; let n = arr . length ; console . log ( 'Largest sum = ' + largestSum ( arr n ));
AusgabeLargest sum = 12Zeitkomplexität: O(n^2).
Raumkomplexität: An).Größte Summe zusammenhängender zunehmender Subarrays unter Verwendung des Kadane-Algorithmus: –
Um das Subarray mit der größten Summe zu erhalten, wird der Ansatz von Kadane verwendet, der jedoch voraussetzt, dass das Array sowohl positive als auch negative Werte enthält. In diesem Fall müssen wir den Algorithmus so ändern, dass er nur bei zusammenhängenden aufsteigenden Subarrays funktioniert.
Im Folgenden erfahren Sie, wie wir den Algorithmus von Kadane modifizieren können, um das zusammenhängend wachsende Subarray mit der größten Summe zu finden:
C++
- Initialisieren Sie zwei Variablen: max_sum und curr_sum mit dem ersten Element des Arrays.
- Durchlaufen Sie das Array beginnend mit dem zweiten Element.
- Wenn das aktuelle Element größer als das vorherige Element ist, fügen Sie es zur curr_sum hinzu. Andernfalls setze curr_sum auf das aktuelle Element zurück.
- Wenn curr_sum größer als max_sum ist, aktualisieren Sie max_sum.
- Nach der Schleife enthält max_sum die größte Summe zusammenhängender ansteigender Subarrays.
Java#includeusing namespace std ; int largest_sum_contiguous_increasing_subarray ( int arr [] int n ) { int max_sum = arr [ 0 ]; int curr_sum = arr [ 0 ]; for ( int i = 1 ; i < n ; i ++ ) { if ( arr [ i ] > arr [ i -1 ]) { curr_sum += arr [ i ]; } else { curr_sum = arr [ i ]; } if ( curr_sum > max_sum ) { max_sum = curr_sum ; } } return max_sum ; } int main () { int arr [] = { 1 1 4 7 3 6 }; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); cout < < largest_sum_contiguous_increasing_subarray ( arr n ) < < endl ; // Output: 44 (1+2+3+5+7+8+9+10) return 0 ; } Python3public class Main { public static int largestSumContiguousIncreasingSubarray ( int [] arr int n ) { int maxSum = arr [ 0 ] ; int currSum = arr [ 0 ] ; for ( int i = 1 ; i < n ; i ++ ) { if ( arr [ i ] > arr [ i - 1 ] ) { currSum += arr [ i ] ; } else { currSum = arr [ i ] ; } if ( currSum > maxSum ) { maxSum = currSum ; } } return maxSum ; } public static void main ( String [] args ) { int [] arr = { 1 1 4 7 3 6 }; int n = arr . length ; System . out . println ( largestSumContiguousIncreasingSubarray ( arr n )); // Output: 44 (1+2+3+5+7+8+9+10) } }C#def largest_sum_contiguous_increasing_subarray ( arr n ): max_sum = arr [ 0 ] curr_sum = arr [ 0 ] for i in range ( 1 n ): if arr [ i ] > arr [ i - 1 ]: curr_sum += arr [ i ] else : curr_sum = arr [ i ] if curr_sum > max_sum : max_sum = curr_sum return max_sum arr = [ 1 1 4 7 3 6 ] n = len ( arr ) print ( largest_sum_contiguous_increasing_subarray ( arr n )) #output 12 (1+4+7)JavaScriptusing System ; class GFG { // Function to find the largest sum of a contiguous // increasing subarray static int LargestSumContiguousIncreasingSubarray ( int [] arr int n ) { int maxSum = arr [ 0 ]; // Initialize the maximum sum // and current sum int currSum = arr [ 0 ]; for ( int i = 1 ; i < n ; i ++ ) { if ( arr [ i ] > arr [ i - 1 ]) // Check if the current // element is greater than the // previous element { currSum += arr [ i ]; // If increasing add the // element to the current sum } else { currSum = arr [ i ]; // If not increasing start a // new increasing subarray // from the current element } if ( currSum > maxSum ) // Update the maximum sum if the // current sum is greater { maxSum = currSum ; } } return maxSum ; } static void Main () { int [] arr = { 1 1 4 7 3 6 }; int n = arr . Length ; Console . WriteLine ( LargestSumContiguousIncreasingSubarray ( arr n )); } } // This code is contributed by akshitaguprzj3
Ausgabe12Zeitkomplexität: O(n).
Quiz erstellen
Raumkomplexität: O(1).
