S obzirom na niz n elementi i cijeli broj k . Zadatak je pronaći broj podniza koji ima maksimalni element veći od K.
Primjeri:
Input : arr[] = {1 2 3} and k = 2.Recommended Practice Broj podnizova Probajte!
Output : 3
All the possible subarrays of arr[] are
{ 1 } { 2 } { 3 } { 1 2 } { 2 3 }
{ 1 2 3 }.
Their maximum elements are 1 2 3 2 3 3.
There are only 3 maximum elements > 2.
Pristup 1: Brojanje podnizova koji imaju najveći broj elemenata<= K and then subtracting from total subarrays.
Ideja je pristupiti problemu prebrojavanjem podnizova čiji je najveći element manji ili jednak k jer je brojanje takvih podnizova lakše. Da biste pronašli broj podniza čiji je najveći element manji ili jednak k, uklonite sve elemente koji su veći od K i pronađite broj podniza s lijevim elementima.
Kada pronađemo gornji broj, možemo ga oduzeti od n*(n+1)/2 da bismo dobili traženi rezultat. Primijetite da može postojati n*(n+1)/2 moguća broja podniza bilo kojeg niza veličine n. Dakle, pronalaženje broja podniza čiji je najveći element manji ili jednak K i njegovo oduzimanje od n*(n+1)/2 daje odgovor.
U nastavku je implementacija ovog pristupa:
C++// C++ program to count number of subarrays // whose maximum element is greater than K. #include
// Java program to count number of subarrays // whose maximum element is greater than K. import java.util.*; class GFG { // Return number of subarrays whose maximum // element is less than or equal to K. static int countSubarray(int arr[] int n int k) { // To store count of subarrays with all // elements less than or equal to k. int s = 0; // Traversing the array. int i = 0; while (i < n) { // If element is greater than k ignore. if (arr[i] > k) { i++; continue; } // Counting the subarray length whose // each element is less than equal to k. int count = 0; while (i < n && arr[i] <= k) { i++; count++; } // Summing number of subarray whose // maximum element is less than equal to k. s += ((count * (count + 1)) / 2); } return (n * (n + 1) / 2 - s); } // Driver code public static void main(String[] args) { int arr[] = { 1 2 3 }; int k = 2; int n = arr.length; System.out.print(countSubarray(arr n k)); } } // This code is contributed by Anant Agarwal.
# Python program to count # number of subarrays # whose maximum element # is greater than K. # Return number of # subarrays whose maximum # element is less than or equal to K. def countSubarray(arr n k): # To store count of # subarrays with all # elements less than # or equal to k. s = 0 # Traversing the array. i = 0 while (i < n): # If element is greater # than k ignore. if (arr[i] > k): i = i + 1 continue # Counting the subarray # length whose # each element is less # than equal to k. count = 0 while (i < n and arr[i] <= k): i = i + 1 count = count + 1 # Summing number of subarray whose # maximum element is less # than equal to k. s = s + ((count*(count + 1))//2) return (n*(n + 1)//2 - s) # Driver code arr = [1 2 3] k = 2 n = len(arr) print(countSubarray(arr n k)) # This code is contributed # by Anant Agarwal.
// C# program to count number of subarrays // whose maximum element is greater than K. using System; class GFG { // Return number of subarrays whose maximum // element is less than or equal to K. static int countSubarray(int[] arr int n int k) { // To store count of subarrays with all // elements less than or equal to k. int s = 0; // Traversing the array. int i = 0; while (i < n) { // If element is greater than k ignore. if (arr[i] > k) { i++; continue; } // Counting the subarray length whose // each element is less than equal to k. int count = 0; while (i < n && arr[i] <= k) { i++; count++; } // Summing number of subarray whose // maximum element is less than equal to k. s += ((count * (count + 1)) / 2); } return (n * (n + 1) / 2 - s); } // Driver code public static void Main() { int[] arr = {1 2 3}; int k = 2; int n = arr.Length; Console.WriteLine(countSubarray(arr n k)); } } // This code is contributed by vt_m.
<script> // Javascript program to count number of subarrays // whose maximum element is greater than K. // Return number of subarrays whose maximum // element is less than or equal to K. function countSubarray(arr n k) { // To store count of subarrays with all // elements less than or equal to k. let s = 0; // Traversing the array. let i = 0; while (i < n) { // If element is greater than k ignore. if (arr[i] > k) { i++; continue; } // Counting the subarray length whose // each element is less than equal to k. let count = 0; while (i < n && arr[i] <= k) { i++; count++; } // Summing number of subarray whose // maximum element is less than equal to k. s += parseInt((count * (count + 1)) / 2 10); } return (n * parseInt((n + 1) / 2 10) - s); } let arr = [1 2 3]; let k = 2; let n = arr.length; document.write(countSubarray(arr n k)); </script>
// PHP program to count number of subarrays // whose maximum element is greater than K. // Return number of subarrays whose maximum // element is less than or equal to K. function countSubarray( $arr $n $k) { // To store count of subarrays with all // elements less than or equal to k. $s = 0; // Traversing the array. $i = 0; while ($i < $n) { // If element is greater than k // ignore. if ($arr[$i] > $k) { $i++; continue; } // Counting the subarray length // whose each element is less // than equal to k. $count = 0; while ($i < $n and $arr[$i] <= $k) { $i++; $count++; } // Summing number of subarray whose // maximum element is less than // equal to k. $s += (($count * ($count + 1)) / 2); } return ($n * ($n + 1) / 2 - $s); } // Driven Program $arr = array( 1 2 3 ); $k = 2; $n = count($arr); echo countSubarray($arr $n $k); // This code is contributed by anuj_67. ?> Izlaz
3
Vremenska složenost: O(n).
Pomoćni prostor: O(1)
Pristup 2: Brojanje podnizova koji imaju max element > K
U ovom pristupu jednostavno pronalazimo broj podnizova koji se mogu formirati uključivanjem elementa na indeksu i koji je veći od K. Dakle, ako pretpostavimo arr [ i ] > K tada će svi podnizovi u kojima je ovaj element prisutan imati vrijednost veću od k, tako da samo izračunavamo sve ove podnizove za svaki element koji je veći od K i dodajemo ih kao odgovor. Prvo inicijaliziramo dvije varijable godine = 0 ovo sadrži odgovor i prethodni = -1 ovo prati indeks prethodnog elementa koji je bio veći od K.
Da bismo to učinili potrebne su nam samo tri vrijednosti za svaki arr [ i ] > K .
- Broj podnizova počevši od indeksa ja . Ovo će biti ( N - i ) . NAPOMENA: U ovo smo uključili podniz koji sadrži jedan element koji je sam ovaj element. { arr [ i ] }
- Broj podnizova koji završavaju ovim indeksom ja ali početni indeks ovih podnizova je nakon indeksa prev prethodnog elementa koji je bio veći od K zašto ovo radimo? Zato što smo za te elemente morali već izračunati svoj odgovor pa ne želimo brojati iste podnizove više od jednom. Dakle, ova vrijednost će se pojaviti ( i - prev - 1 ) . NAPOMENA: Ovdje oduzimamo 1 jer smo već izbrojali podniz { arr [ i ] } koji ima sebe kao jedan element. Vidi gornju bilješku.
- Broj podnizova s početnim indeksom manjim od ja ali veći od prev a završni indeks veći od ja . Stoga svi podnizovi u kojima je arr[i] između. To možemo izračunati množenjem iznad dvije vrijednosti. Recimo ih kao L = ( N - i - 1 ) i R = ( i - prev -1 ). Sada samo množimo ove L i R jer za svaki 1 indeks na lijevoj strani od i postoji R indeks koji može napraviti različite podnizove osnovne matematičke stvari. Tako ovo postaje L * R . Primijetite da smo ovdje u val od L zapravo oduzeli 1, ako to ne učinimo, tada uključujemo indeks i u naš L*R što će značiti da smo ponovno uključili podnizove tipa broj 1. Vidi točku 1.
U nastavku je implementacija ovog pristupa:
C++// C++ program to count number of subarrays // whose maximum element is greater than K. #include
// Java program to count number of subarrays // whose maximum element is greater than K. import java.util.*; public class GFG { static long countSubarray(int arr[] int n int k) { long ans = 0 ; int prev = - 1; //prev for keeping track of index of previous element > k; for(int i = 0 ; i < n ; i++ ) { if ( arr [ i ] > k ) { ans += n - i ; //subarrays starting at index i. ans += i - prev - 1 ; //subarrays ending at index i but starting after prev. ans += ( n - i - 1 ) * 1L * ( i - prev - 1 ) ; //subarrays having index i element in between. prev = i; // updating prev } } return ans; } // Driver code public static void main(String[] args) { int arr[] = { 4 5 1 2 3 }; int k = 2; int n = arr.length; System.out.print(countSubarray(arr n k)); } } //This Code is contributed by Manjeet Singh
# Python program to count number of subarrays # whose maximum element is greater than K. def countSubarray( arr n k): ans = 0 ; prev = - 1; #prev for keeping track of index of previous element > k; for i in range(0n): if ( arr [ i ] > k ) : ans += n - i ; #subarrays starting at index i. ans += i - prev - 1 ; #subarrays ending at index i but starting after prev. ans += ( n - i - 1 ) * ( i - prev - 1 ) ; #subarrays having index i element in between. prev = i; # updating prev return ans; # Driven Program arr = [ 4 5 1 2 3 ]; k = 2; n = len(arr); print(countSubarray(arr n k)); # this code is contributed by poojaagarwal2.
// C# program to count number of subarrays // whose maximum element is greater than K. using System; public class GFG { static long countSubarray(int[] arr int n int k) { long ans = 0; int prev = -1; // prev for keeping track of index of // previous element > k; for (int i = 0; i < n; i++) { if (arr[i] > k) { ans += n - i; // subarrays starting at index // i. ans += i - prev - 1; // subarrays ending at index i // but starting after prev. ans += (n - i - 1) * (long)1 * (i - prev - 1); // subarrays having index i // element in between. prev = i; // updating prev } } return ans; } // Driver code public static void Main(string[] args) { int[] arr = { 4 5 1 2 3 }; int k = 2; int n = arr.Length; Console.Write(countSubarray(arr n k)); } } // This Code is contributed by Karandeep1234
// Javascript program to count number of subarrays // whose maximum element is greater than K. function countSubarray(arr n k) { let ans = 0 ; //prev for keeping track of index of previous element > k; let prev = - 1; for(let i = 0 ; i < n ; i++ ) { if ( arr [ i ] > k ) { //subarrays starting at index i. ans += n - i ; //subarrays ending at index i but starting after prev. ans += i - prev - 1 ; //subarrays having index i element in between. ans += ( n - i - 1 ) * 1 * ( i - prev - 1 ) ; // updating prev prev = i; } } return ans; } // Driven Program let arr = [ 4 5 1 2 3 ]; let k = 2; let n = arr.length; document.write(countSubarray(arr n k));
Izlaz
12
Vremenska složenost: O(n).
Pristup 3: Tehnika kliznih prozora.
Algoritam:
1. Inicijalizirati varijablu godine = 0 varijabla maxElement = 0 i varijabla broj = 0 .
2. Iterirajte niz nizom radeći sljedeće za svaki element:
a. Ako trenutni element tj. dosp[i] je veći od trenutnog maksimuma ažurirajte maksimum tj. Radio = arr ] i resetirajte brojač na 0.
b. Ako je trenutni element manji ili jednak trenutnom maksimumu, tada povećajte broj.
c. Ako maxElement tada je grteater od k dodati broj podnizova do konačnog odgovora i ažuriranja maxElement na trenutni element.
3. Vrati Konačni odgovor.
Ovdje je implementacija tehnike kliznih prozora.
C++#include
#include
import java.util.*; public class GFG { // Function to count the number of subarrays with the maximum element greater than k public static int countSubarray(int[] arr int n int k) { int maxElement = 0; // Variable to store the maximum element encountered so far int count = 0; // Variable to count the length of the subarray with elements <= k int ans = 0; // Variable to store the final result for (int i = 0; i < n; i++) { if (arr[i] > maxElement) { // If the current element is greater than the maximum element // update the maximum element and reset the count to zero. maxElement = arr[i]; count = 0; } else { // increment the count count++; } if (maxElement > k) { // If the maximum element in the current subarray is greater than k // add the count of subarrays ending at the current index (i - count + 1) to the result. ans += (i - count + 1); // Reset the maximum element and count to zero. maxElement = arr[i]; count = 0; } } // Return the final result return ans; } public static void main(String[] args) { int[] arr = {1 2 3 4}; int k = 1; int n = arr.length; // Call the countSubarray function to count the number of subarrays with maximum element greater than k int result = countSubarray(arr n k); System.out.println(result); } } // THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL
def countSubarray(arr n k): maxElement count ans = 0 0 0 for i in range(n): if arr[i] > maxElement: maxElement = arr[i] count = 0 else: count += 1 if maxElement > k: ans += (i - count + 1) maxElement = arr[i] count = 0 ans += (count * (count + 1)) // 2 return ans arr = [1 2 3 4] k = 1 n = len(arr) print(countSubarray(arr n k)) # This code is contributed by Vaibhav Saroj
using System; public class Program { public static int CountSubarray(int[] arr int n int k) { int maxElement = 0 count = 0 ans = 0; for(int i=0; i<n; i++) { if(arr[i] > maxElement) { maxElement = arr[i]; count = 0; } else { count++; } if(maxElement > k) { ans += (i - count + 1); maxElement = arr[i]; count = 0; } } ans += (count * (count + 1)) / 2; return ans; } public static void Main() { int[] arr = {1 2 3 4}; int k = 1; int n = arr.Length; Console.WriteLine(CountSubarray(arr n k)); } } // This code is contributed by Vaibhav Saroj
function countSubarray(arr n k) { let maxElement = 0 count = 0 ans = 0; for(let i=0; i<n; i++) { if(arr[i] > maxElement) { maxElement = arr[i]; count = 0; } else { count++; } if(maxElement > k) { ans += (i - count + 1); maxElement = arr[i]; count = 0; } } ans += (count * (count + 1)) / 2; return ans; } let arr = [1 2 3 4]; let k = 1; let n = arr.length; console.log(countSubarray(arr n k)); // This code is contributed by Vaibhav Saroj
Izlaz
9
Tehnici kliznih prozora doprinosi Vaibhav Saroj .
Vremenska složenost: O( n ).
Prostorna složenost: O( 1 ).