logo

TechCodeview

Största summa sammanhängande ökande subarray

Prova det på GfG Practice ' title= #practiceLinkDiv { display: ingen !viktigt; }

Givet en matris med n positiva distinkta heltal. Problemet är att hitta den största summan av sammanhängande ökande subarray i O(n) tidskomplexitet.

Exempel:  

    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 Girig räv Prova!

A enkel lösning är att generera alla subarrayer och beräkna deras summor. Returnera slutligen subarrayen med maximal summa. Tidskomplexiteten för denna lösning är O(n2).



java math.random

En effektiv lösning bygger på att alla moment är positiva. Så vi överväger längst ökande subarrayer och jämför deras summor. Till ökande subarrayer kan inte överlappa så vår tidskomplexitet blir O(n).

Algoritm:  

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

Nedan är implementeringen av ovanstående algoritm.

värde på java-strängen
C++ 
// C++ implementation of largest sum // contiguous increasing subarray #include    using 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; }
Java 
// 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 
# 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# 
// 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.
JavaScript 
<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 
 // 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. ?>

Produktion 
Largest sum = 12

Tidskomplexitet: O(n)

 

Största summa sammanhängande ökande subarray Använder Rekursion : 

Rekursiv algoritm för att lösa detta problem:

Här är steg-för-steg-algoritmen för problemet:

  1. Funktionen 'största summa' tar array 'arr' och storleken är 'n'.
  2. Om   'n==1' återvänd sedan arr[0]th element.
  3. Om 'n != 1' sedan ett rekursivt anrop av funktionen 'största summa'   för att hitta den största summan av undermatrisen 'arr[0...n-1]' exklusive det sista elementet 'arr[n-1]' .
  4.  Genom att iterera över matrisen i omvänd ordning som börjar med det näst sista elementet beräkna summan av den ökande delmatrisen som slutar på 'arr[n-1]' . Om ett element är mindre än nästa ska det läggas till den aktuella summan. Annars bör slingan brytas.
  5. Returnera sedan maximalt av den största summan d.v.s. ' return max(max_sum curr_sum);' .
     

Här är implementeringen av ovanstående algoritm:

C++ 
#include    using 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.
C 
#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 = %dn' largestSum(arr n));  return 0; } // This code is contributed by Vaibhav Saroj.
Java 
/*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.
Python 
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# 
// 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
JavaScript 
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));
PHP 
 // 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); ?>

Produktion 
Largest sum = 12

Tidskomplexitet: O(n^2).
Utrymmes komplexitet: På).

Största summa sammanhängande ökande subarray Använder  Kadanes algoritm:-

För att få den största summasubmatrisen används Kadanes tillvägagångssätt, men det förutsätter att matrisen innehåller både positiva och negativa värden. I det här fallet måste vi ändra algoritmen så att den bara fungerar på sammanhängande stigande subarrayer.

Följande är hur vi kan modifiera Kadanes algoritm för att hitta den största summan sammanhängande ökande subarrayen:

  1. Initiera två variabler: max_sum och curr_sum till det första elementet i arrayen.
  2. Slinga genom arrayen med början från det andra elementet.
  3. om det aktuella elementet är större än det föregående elementet lägg till det till curr_sum. Återställ annars curr_sum till det aktuella elementet.
  4. Om curr_sum är större än max_sum uppdatera max_sum.
  5. Efter loopen kommer max_sum att innehålla den största summan sammanhängande ökande subarray.
     
C++ 
#include    using 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; }
Java 
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)  } }
Python3 
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)
C# 
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 
 // 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

Produktion 
12

Tidskomplexitet: O(n).
Rymdkomplexitet: O(1).

tecken till sträng java
Skapa frågesport