#practiceLinkDiv { display: none !important; }Podana je matrika n pozitivnih različnih celih števil. Težava je najti največjo vsoto sosednjih naraščajočih podnizov v O(n) časovni kompleksnosti.
Primeri:
Input : arr[] = {2 1 4 7 3 6}Recommended Practice Pohlepna lisica Poskusite!
Output : 12
Contiguous Increasing subarray {1 4 7} = 12
Input : arr[] = {38 7 8 10 12}
Output : 38
A preprosta rešitev je za ustvarite vse podnize in izračunajte njihove vsote. Končno vrni podmatriko z največjo vsoto. Časovna kompleksnost te rešitve je O(n2).
An učinkovita rešitev temelji na dejstvu, da so vsi elementi pozitivni. Zato upoštevamo najdaljše naraščajoče podnize in primerjamo njihove vsote. Naraščajoče podnize se ne morejo prekrivati, tako da naša časovna kompleksnost postane O(n).
Algoritem:
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
Spodaj je implementacija zgornjega algoritma.
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. ?> Izhod
Largest sum = 12
Časovna zahtevnost: O(n)
Največja vsota sosednje naraščajoče podmatrike Uporaba Rekurzija :
Rekurzivni algoritem za rešitev te težave:
Tu je algoritem težave po korakih:
- Funkcija 'največjaVsota' sprejme niz 'arr' in velikost je 'n'.
- če 'n==1' potem se vrni pride[0]th element.
- če 'n != 1' nato rekurziven klic funkcije 'največjaVsota' da poiščemo največjo vsoto podniza 'arr[0...n-1]' razen zadnjega elementa 'arr[n-1]' .
- S ponavljanjem matrike v obratnem vrstnem redu, začenši s predzadnjim elementom, izračunajte vsoto naraščajoče podmatrike, ki se konča pri 'arr[n-1]' . Če je en element manjši od naslednjega, ga je treba dodati trenutni vsoti. V nasprotnem primeru bi morala biti zanka prekinjena.
- Nato vrnite maksimum največje vsote, tj. ' return max(max_sum curr_sum);' .
Tukaj je izvedba zgornjega algoritma:
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); ?> Izhod
Largest sum = 12
Časovna zapletenost: O(n^2).
Kompleksnost prostora: O(n).
Največja vsota sosednjih naraščajočih podnizov z uporabo Kadanejevega algoritma:-
Za pridobitev največje podmatrike vsote se uporablja Kadanejev pristop, vendar predpostavlja, da matrika vsebuje pozitivne in negativne vrednosti. V tem primeru moramo algoritem spremeniti tako, da bo deloval le na sosednjih naraščajočih podnizih.
Sledi način, kako lahko spremenimo Kadanov algoritem, da poiščemo največjo vsoto sosednjih naraščajočih podnizov:
- Inicializirajte dve spremenljivki: max_sum in curr_sum v prvi element matrike.
- Skozi matriko začnite z drugim elementom.
- če je trenutni element večji od prejšnjega elementa, ga dodajte curr_sum. V nasprotnem primeru ponastavite curr_sum na trenutni element.
- Če je curr_sum večja od max_sum, posodobi max_sum.
- Po zanki bo max_sum vsebovala največjo vsoto, ki se povečuje podmatriko.
#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
Izhod
12
Časovna zahtevnost: O(n).
Zahtevnost prostora: O(1).