Skip to content
Related Articles

Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Minimize prize count required such that smaller value gets less prize in an adjacent pair

  • Last Updated : 15 Apr, 2021

Given an array arr[] of length N, the task is to find the minimum number of prizes required such that if two elements are adjacent, then elements with smaller value gets a less number of prizes compared to its adjacent elements with greater value. 
Note: Each elements will get at least one prize. 

Examples:

Input: arr[] = {1, 2, 2, 3} 
Output: 6 
Explanation: 
Element at index {0} will get {1} prize. 
Element at index {1} will get {2} prizes. 
Element at index {2} will get {1} prizes. 
Element at index {3} will get {2} prizes. 
So, the total number of prizes required to satisfy 
the above conditions are 6

Input: arr[] = {3, 2, 2, 1} 
Output: 6 
Explanation: 
Element at index {0} will get {2} prize. 
Element at index {1} will get {1} prizes. 
Element at index {2} will get {2} prizes. 
Element at index {3} will get {1} prizes. 
So, the total number of prizes required to satisfy 
the above conditions are 6



Naive Approach: Traverse over the elements of the array and for each element of the array find the consecutive smaller elements at the left of the element and find the consecutive smaller elements on the right of that index.

Prize at index i = max(Consecutive smaller elements at left, Consecutive smaller elements at right, 1)

Below is the implementation of the above approach:

C++




// C++ implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
 
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
int findMinPrizes(int arr[], int n)
{
    int totalPrizes = 0, j, x, y;
 
    // Loop to iterate over every
    // elements of the array
    for (int i = 0; i < n; i++) {
        x = 1;
        j = i;
 
        // Loop to find the consecutive
        // smaller elements at left
        while (j > 0 && arr[j] > arr[j - 1]) {
            x++;
            j--;
        }
        j = i;
        y = 1;
 
        // Loop to find the consecutive
        // smaller elements at right
        while (j < n - 1 && arr[j] > arr[j + 1]) {
            y++;
            j++;
        }
 
        totalPrizes += max({ x, y });
    }
    cout << totalPrizes << endl;
 
    return 0;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    findMinPrizes(arr, n);
}
Java



// Java implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
import java.util.*;
class GFG{
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
static int findMinPrizes(int arr[], int n)
{
    int totalPrizes = 0, j, x, y;
 
    // Loop to iterate over every
    // elements of the array
    for (int i = 0; i < n; i++)
    {
        x = 1;
        j = i;
 
        // Loop to find the consecutive
        // smaller elements at left
        while (j > 0 && arr[j] > arr[j - 1])
        {
            x++;
            j--;
        }
        j = i;
        y = 1;
 
        // Loop to find the consecutive
        // smaller elements at right
        while (j < n - 1 && arr[j] > arr[j + 1])
        {
            y++;
            j++;
        }
 
        totalPrizes += Math.max(x, y );
    }
    System.out.print(totalPrizes + "\n");
 
    return 0;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 2, 3 };
    int n = arr.length;
 
    findMinPrizes(arr, n);
}
}
 
// This code is contributed by gauravrajput1
Python3



# Python3 implementation to find the
# minimum prizes required such
# that adjacent smaller elements
# gets less number of prizes
 
# Function to find the minimum
# number of required such that
# adjacent smaller elements gets
# less number of prizes
def findMinPrizes(arr, n):
     
    totalPrizes = 0
     
    # Loop to iterate over every
    # elements of the array
    for i in range(n):
        x = 1
        j = i
         
        # Loop to find the consecutive
        # smaller elements at left
        while (j > 0 and arr[j] > arr[j - 1]):
            x += 1
            j -= 1
         
        j = i
        y = 1
         
        # Loop to find the consecutive
        # smaller elements at right
        while (j < n - 1 and arr[j] >
                             arr[j + 1]):
            y += 1
            j += 1
             
        totalPrizes += max(x, y)
         
    print(totalPrizes)
 
# Driver code
arr = [ 1, 2, 2, 3 ]
n = len(arr)
 
findMinPrizes(arr, n)
 
# This code is contributed by stutipathak31jan
C#



// C# implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
using System;
 
class GFG{
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
static int findMinPrizes(int []arr, int n)
{
    int totalPrizes = 0, j, x, y;
 
    // Loop to iterate over every
    // elements of the array
    for(int i = 0; i < n; i++)
    {
        x = 1;
        j = i;
 
        // Loop to find the consecutive
        // smaller elements at left
        while (j > 0 && arr[j] > arr[j - 1])
        {
            x++;
            j--;
        }
        j = i;
        y = 1;
 
        // Loop to find the consecutive
        // smaller elements at right
        while (j < n - 1 &&
          arr[j] > arr[j + 1])
        {
            y++;
            j++;
        }
        totalPrizes += Math.Max(x, y);
    }
    Console.Write(totalPrizes + "\n");
 
    return 0;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 2, 3 };
    int n = arr.Length;
 
    findMinPrizes(arr, n);
}
}
 
// This code is contributed by Amit Katiyar
Javascript



<script>
 
    // Javascript implementation to find the
    // minimum prizes required such
    // that adjacent smaller elements
    // gets less number of prizes 
     
    // Function to find the minimum
    // number of required such that
    // adjacent smaller elements gets
    // less number of prizes
    function findMinPrizes(arr, n)
    {
        let totalPrizes = 0, j, x, y;
 
        // Loop to iterate over every
        // elements of the array
        for (let i = 0; i < n; i++) {
            x = 1;
            j = i;
 
            // Loop to find the consecutive
            // smaller elements at left
            while (j > 0 && arr[j] > arr[j - 1]) {
                x++;
                j--;
            }
            j = i;
            y = 1;
 
            // Loop to find the consecutive
            // smaller elements at right
            while (j < n - 1 && arr[j] > arr[j + 1]) {
                y++;
                j++;
            }
 
            totalPrizes += Math.max( x, y );
        }
        document.write(totalPrizes);
 
        return 0;
    }
     
    let arr = [ 1, 2, 2, 3 ];
    let n = arr.length;
    findMinPrizes(arr, n);
     
    // This code is contributed by divyesh072019.
</script>
Output: 
6
Performance Analysis:
  • Time Complexity: O(N2)
  • Auxiliary Space: O(1)
Efficient Approach: The idea is to precompute the count of consecutive smaller elements at left and right for every element of the array. It means that, if an element on the left is smaller, then all the smaller elements at the left of that element will also be smaller to the current element. i.e.
if (arr[i-1] < arr[i])
    smallerLeft[i] = smallerLeft[i-1] + 1
Similarly, the consecutive smaller elements can be computed using the fact that, if an element on the right is greater than the current element then the consecutive greater elements on the right will also be greater than the current element. i.e.
if (arr[i] < arr[i+1])
    smallerRight[i] = smallerRight[i+1] + 1
Below is the implementation of the above approach:
C++



// C++ implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
 
#include <bits/stdc++.h>
 
using namespace std;
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
int minPrizes(int arr[], int n)
{
    int dpLeft[n];
 
    dpLeft[0] = 1;
 
    // Loop to compute the smaller
    // elements at the left
    for (int i = 1; i < n; i++) {
 
        if (arr[i] > arr[i - 1]) {
 
            dpLeft[i] = dpLeft[i - 1] + 1;
        }
        else {
 
            dpLeft[i] = 1;
        }
    }
 
    int dpRight[n];
 
    dpRight[n - 1] = 1;
 
    // Loop to find the smaller
    // elements at the right
    for (int i = n - 2; i >= 0; i--) {
 
        if (arr[i] > arr[i + 1]) {
 
            dpRight[i] = dpRight[i + 1] + 1;
        }
        else {
 
            dpRight[i] = 1;
        }
    }
 
    int totalPrizes = 0;
 
    // Loop to find the minimum
    // prizes required
    for (int i = 0; i < n; i++) {
 
        totalPrizes += max(dpLeft[i],
                           dpRight[i]);
    }
    cout << totalPrizes << endl;
 
    return 0;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    minPrizes(arr, n);
 
    return 0;
}
Java



// Java implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
import java.util.*;
 
class GFG{
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
static int minPrizes(int arr[], int n)
{
    int []dpLeft = new int[n];
 
    dpLeft[0] = 1;
 
    // Loop to compute the smaller
    // elements at the left
    for(int i = 1; i < n; i++)
    {
        if (arr[i] > arr[i - 1])
        {
            dpLeft[i] = dpLeft[i - 1] + 1;
        }
        else
        {
            dpLeft[i] = 1;
        }
    }
 
    int []dpRight = new int[n];
 
    dpRight[n - 1] = 1;
 
    // Loop to find the smaller
    // elements at the right
    for(int i = n - 2; i >= 0; i--)
    {
        if (arr[i] > arr[i + 1])
        {
            dpRight[i] = dpRight[i + 1] + 1;
        }
        else
        {
            dpRight[i] = 1;
        }
    }
 
    int totalPrizes = 0;
 
    // Loop to find the minimum
    // prizes required
    for(int i = 0; i < n; i++)
    {
        totalPrizes += Math.max(dpLeft[i],
                               dpRight[i]);
    }
    System.out.print(totalPrizes + "\n");
    return 0;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 2, 3 };
    int n = arr.length;
 
    minPrizes(arr, n);
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 implementation to find the
# minimum prizes required such
# that adjacent smaller elements
# gets less number of prizes
 
# Function to find the minimum
# number of required such that
# adjacent smaller elements gets
# less number of prizes
def minPrizes(arr, n):
     
    dpLeft = [0] * n
    dpLeft[0] = 1
     
    # Loop to compute the smaller
    # elements at the left
    for i in range(n):
        if arr[i] > arr[i - 1]:
            dpLeft[i] = dpLeft[i - 1] + 1
             
        else:
            dpLeft[i] = 1
         
    dpRight = [0] * n
    dpRight[-1] = 1
     
    # Loop to find the smaller
    # elements at the right
    for i in range(n - 2, -1, -1):
        if arr[i] > arr[i + 1]:
            dpRight[i] = dpRight[i + 1] + 1
             
        else:
            dpRight[i] = 1
     
    totalPrizes = 0
     
    # Loop to find the minimum
    # prizes required
    for i in range(n):
        totalPrizes += max(dpLeft[i],
                           dpRight[i])
         
    print(totalPrizes)
 
# Driver code
arr = [ 1, 2, 2, 3 ]
n = len(arr)
     
minPrizes(arr, n)
 
# This code is contributed by stutipathak31jan
C#



// C# implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
using System;
 
class GFG{
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
static int minPrizes(int []arr, int n)
{
    int []dpLeft = new int[n];
 
    dpLeft[0] = 1;
 
    // Loop to compute the smaller
    // elements at the left
    for(int i = 1; i < n; i++)
    {
        if (arr[i] > arr[i - 1])
        {
            dpLeft[i] = dpLeft[i - 1] + 1;
        }
        else
        {
            dpLeft[i] = 1;
        }
    }
 
    int []dpRight = new int[n];
 
    dpRight[n - 1] = 1;
 
    // Loop to find the smaller
    // elements at the right
    for(int i = n - 2; i >= 0; i--)
    {
        if (arr[i] > arr[i + 1])
        {
            dpRight[i] = dpRight[i + 1] + 1;
        }
        else
        {
            dpRight[i] = 1;
        }
    }
 
    int totalPrizes = 0;
 
    // Loop to find the minimum
    // prizes required
    for(int i = 0; i < n; i++)
    {
        totalPrizes += Math.Max(dpLeft[i],
                               dpRight[i]);
    }
    Console.Write(totalPrizes + "\n");
    return 0;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 2, 3 };
    int n = arr.Length;
 
    minPrizes(arr, n);
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation to find the
// minimum prizes required such
// that adjacent smaller elements
// gets less number of prizes
 
// Function to find the minimum
// number of required such that
// adjacent smaller elements gets
// less number of prizes
function minPrizes(arr, n)
{
    let dpLeft = new Array(n);
 
    dpLeft[0] = 1;
 
    // Loop to compute the smaller
    // elements at the left
    for(let i = 1; i < n; i++)
    {
        if (arr[i] > arr[i - 1])
        {
            dpLeft[i] = dpLeft[i - 1] + 1;
        }
        else
        {
            dpLeft[i] = 1;
        }
    }
 
    let dpRight = new Array(n);
 
    dpRight[n - 1] = 1;
 
    // Loop to find the smaller
    // elements at the right
    for(let i = n - 2; i >= 0; i--)
    {
        if (arr[i] > arr[i + 1])
        {
            dpRight[i] = dpRight[i + 1] + 1;
        }
        else
        {
            dpRight[i] = 1;
        }
    }
 
    let totalPrizes = 0;
 
    // Loop to find the minimum
    // prizes required
    for(let i = 0; i < n; i++)
    {
        totalPrizes += Math.max(dpLeft[i],
                               dpRight[i]);
    }
    document.write(totalPrizes + "</br>");
    return 0;
}
 
// Driver code
let arr = [ 1, 2, 2, 3 ];
let n = arr.length;
 
minPrizes(arr, n);
 
// This code is contributed by suresh07
 
</script>
Output: 
6
Performance Analysis:
  • Time Complexity: O(N)
  • Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Priority queue of pairs in C++ with ordering by first and second element
Next

Check if there exists a permutation of given string which doesn't contain any monotonous substring
Recommended Articles
Page :
Count of distinct N-size Arrays with elements upto K such that adjacent element pair is either ascending or non-multiples
18, Aug 21
Count of array elements which is smaller than both its adjacent elements
22, May 20
Maximize value at Kth index to create N size array with adjacent difference 1 and sum less than M
17, Jun 21
Count of integers of length N and value less than K such that they contain digits only from the given set
02, Jul 19
Minimize cost of painting N houses such that adjacent houses have different colors
15, Feb 21
Minimize length of an array by repeatedly removing elements that are smaller than the next element
17, Jun 21
Store duplicate keys-values pair and sort the key-value pair by key
26, Apr 20
Minimize operations required to make each element of Array equal to it's index value
03, Jul 20
Maximum profit such that total stolen value is less than K to get bonus
15, Jul 20
Minimum operations required to modify the array such that parity of adjacent elements is different
19, Feb 19
Minimize count of flips required to make sum of the given array equal to 0
31, Jan 21
Count of elements having Euler's Totient value one less than itself
03, Jul 20
Longest non-decreasing subsequence having difference between adjacent elements less than D
19, Oct 21
Find a pair (n,r) in an integer array such that value of nPr is maximum
11, Oct 19
Find a pair (n,r) in an integer array such that value of nCr is maximum
11, Oct 19
Minimize the maximum difference of adjacent elements after at most K insertions
07, May 20
Minimize swaps of adjacent characters to sort every possible rearrangement of given Binary String
03, Jan 21
Minimize the cost to make all the adjacent elements distinct in an Array
09, Jun 20
Minimize the maximum absolute difference of adjacent elements in a circular array
30, Apr 20
Minimize the maximum difference between adjacent elements in an array
08, Apr 20
Minimize count of array elements to be removed such that at least K elements are equal to their index values
20, Sep 21
Count of minimum reductions required to get the required sum K
20, Jun 20
Count of arrays in which all adjacent elements are such that one of them divide the another
02, May 17
Count ways to generate N-length array with 0s, 1s, and 2s such that sum of all adjacent pairwise products is K
28, Oct 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rrlinus
@rrlinus
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox