#practiceLinkDiv { display: none! importante; }Dato un array di n interi distinti positivi. Il problema è trovare la somma più grande di sottoarray crescenti contigui con complessità temporale O(n).
Esempi:
Input : arr[] = {2 1 4 7 3 6}Recommended Practice Volpe golosa Provalo!
Output : 12
Contiguous Increasing subarray {1 4 7} = 12
Input : arr[] = {38 7 8 10 12}
Output : 38
UN soluzione semplice è quello generare tutti i sottoarray e calcolare le loro somme. Infine restituisce il sottoarray con la somma massima. La complessità temporale di questa soluzione è O(n2).
UN soluzione efficiente si basa sul fatto che tutti gli elementi sono positivi. Quindi consideriamo i sottoarray crescenti più lunghi e confrontiamo le loro somme. Poiché i sottoarray crescenti non possono sovrapporsi, la nostra complessità temporale diventa O(n).
Algoritmo:
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
Di seguito è riportata l'implementazione dell'algoritmo precedente.
C++// C++ implementation of largest sum // contiguous increasing subarray #include
// 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)); } }
# 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.
// 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.
<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>
// PHP implementation of largest sum // contiguous increasing subarray // Returns sum of longest // increasing subarray. function largestSum($arr $n) { $INT_MIN = 0; // Initialize result $result = $INT_MIN; // Note that i is incremented // by inner loop also so overall // time complexity is O(n) for ($i = 0; $i < $n; $i++) { // Find sum of longest // increasing subarray // starting from arr[i] $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 { $arr = array(1 1 4 7 3 6); $n = sizeof($arr) / sizeof($arr[0]); echo 'Largest sum = ' largestSum($arr $n); return 0; } // This code is contributed by nitin mittal. ?> Produzione
Largest sum = 12
Complessità temporale: O(n)
Somma più grande contiguo crescente sottoarray Using Ricorsione :
Algoritmo ricorsivo per risolvere questo problema:
Ecco l'algoritmo passo passo del problema:
- La funzione 'somma più grande' prende l'array "arr" e la sua dimensione è 'N'.
- Se 'n==1' poi ritorna arr[0]esimo elemento.
- Se 'n!= 1' quindi una chiamata ricorsiva alla funzione 'somma più grande' per trovare la somma più grande del sottoarray 'arr[0...n-1]' escluso l'ultimo elemento 'arr[n-1]' .
- Iterando sull'array in ordine inverso iniziando dal penultimo elemento calcola la somma del sottoarray crescente che termina in 'arr[n-1]' . Se un elemento è più piccolo del successivo dovrebbe essere aggiunto alla somma corrente. Altrimenti il loop dovrebbe essere interrotto.
- Quindi restituisci il massimo della somma più grande, ad es. 'restituisce max(somma_massima somma_curr);' .
Ecco l'implementazione dell'algoritmo di cui sopra:
C++#include
#include
/*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.
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.
// 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 Kumar
function 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));
// Recursive function to find the largest sum // of contiguous increasing subarray function 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 = $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 $arr = array(1 1 4 7 3 6); $n = count($arr); echo 'Largest sum = ' . largestSum($arr $n); ?> Produzione
Largest sum = 12
Complessità temporale: O(n^2).
Complessità spaziale: SU).
logica di trasferimento dei registri
Sottoarray crescente contiguo con somma più grande Utilizzando l'algoritmo di Kadane: -
Per ottenere la somma più grande del sottoarray viene utilizzato l'approccio di Kadane, tuttavia presuppone che l'array contenga sia valori positivi che negativi. In questo caso dobbiamo modificare l'algoritmo in modo che funzioni solo su sottoarray crescenti contigui.
Di seguito è riportato come possiamo modificare l'algoritmo di Kadane per trovare la somma più grande del sottoarray crescente contiguo:
- Inizializza due variabili: max_sum e curr_sum sul primo elemento dell'array.
- Passa attraverso l'array partendo dal secondo elemento.
- se l'elemento corrente è maggiore dell'elemento precedente aggiungilo a curr_sum. Altrimenti reimposta curr_sum sull'elemento corrente.
- Se curr_sum è maggiore di max_sum, aggiorna max_sum.
- Dopo il ciclo max_sum conterrà la somma più grande contigua al sottoarray crescente.
#include
public 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) } }
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)
using 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
// Javascript code for above approach // Function to find the largest sum of a contiguous // increasing subarray function LargestSumContiguousIncreasingSubarray(arr n) { let maxSum = arr[0]; // Initialize the maximum sum // and current sum let currSum = arr[0]; for (let 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; } let arr = [ 1 1 4 7 3 6 ]; let n = arr.length; console.log(LargestSumContiguousIncreasingSubarray(arr n)); // This code is contributed by Pushpesh Raj
Produzione
12
Complessità temporale: O(n).
Complessità spaziale: O(1).