#practiceLinkDiv { display: none !important; }Adott egy n pozitív különböző egész számból álló tömb. A probléma az O(n) időbonyolultságban az összefüggő növekvő altömb legnagyobb összegének megtalálása.
Példák:
Input : arr[] = {2 1 4 7 3 6}Recommended Practice Kapzsi Róka Próbáld ki!
Output : 12
Contiguous Increasing subarray {1 4 7} = 12
Input : arr[] = {38 7 8 10 12}
Output : 38
A egyszerű megoldás az, hogy generálja az összes altömböt és kiszámolják az összegüket. Végül adja vissza az altömböt a maximális összeggel. Ennek a megoldásnak az időbonyolultsága O(n2).
An hatékony megoldás azon alapul, hogy minden elem pozitív. Tehát figyelembe vesszük a leghosszabb növekedésű résztömböket, és összehasonlítjuk az összegüket. A növekvő altömbök nem fedhetik át egymást, így időbonyolításunk O(n) lesz.
Algoritmus:
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
Az alábbiakban bemutatjuk a fenti algoritmus megvalósítását.
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. ?> Kimenet
Largest sum = 12
Időbonyolultság: O(n)
java véletlenszám generátor
Legnagyobb összegű összefüggő növekvő alrendszer használata Rekurzió :
Rekurzív algoritmus a probléma megoldására:
Íme a probléma lépésről lépésre történő algoritmusa:
- A funkció "legnagyobb összeg" tömböt vesz fel 'arr' és a mérete 'n'.
- Ha 'n==1' majd vissza arr[0]th elem.
- Ha 'n != 1' majd egy rekurzív meghívja a függvényt "legnagyobb összeg" hogy megtaláljuk az altömb legnagyobb összegét 'arr[0...n-1]' az utolsó elemet kivéve "arr[n-1]" .
- A második utolsó elemmel kezdődő tömb fordított sorrendben történő iterálásával számítsa ki a növekvő altömb összegét, amely "arr[n-1]" . Ha az egyik elem kisebb, mint a következő, akkor hozzá kell adni az aktuális összeghez. Ellenkező esetben a hurkot meg kell szakítani.
- Ezután adja vissza a legnagyobb összeg maximumát, pl. ' return max(max_sum curr_sum);' .
Íme a fenti algoritmus megvalósítása:
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); ?> Kimenet
Largest sum = 12
Időbeli összetettség: O(n^2).
A tér összetettsége: On).
A legnagyobb összegű összefüggő növekvő altömb Kadane algoritmusát használva:-
A legnagyobb összegű altömb meghatározásához Kadane-féle megközelítést alkalmazunk, azonban ez feltételezi, hogy a tömb pozitív és negatív értékeket is tartalmaz. Ebben az esetben meg kell változtatnunk az algoritmust úgy, hogy az csak összefüggő növekvő altömbökön működjön.
egyesült államok hány város
Az alábbiakban bemutatjuk, hogyan módosíthatjuk Kadane algoritmusát, hogy megtaláljuk a legnagyobb összegű összefüggő növekvő altömböt:
- A tömb első eleméhez inicializáljon két változót: max_sum és curr_sum.
- A második elemtől kiindulva görgessen végig a tömbön.
- ha az aktuális elem nagyobb, mint az előző elem, adja hozzá a curr_sum értékhez. Ellenkező esetben állítsa vissza a curr_sum-ot az aktuális elemre.
- Ha a curr_sum nagyobb, mint a max_sum, frissítse a max_sum értéket.
- A ciklus után a max_sum a legnagyobb összeget fogja tartalmazni a növekvő növekvő altömbben.
#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
Kimenet
12
Időbonyolultság: O(n).
A tér összetettsége: O(1).