Count subarrays for every array element in which they are the minimum

import java.util.*;

class Main {
    
    // Function to count subarrays for every array element in 
    // which they are minimum
    static List<Integer> countingSubarray(List<Integer> arr, int n) {
        List<Integer> ans = new ArrayList<>(Collections.nCopies(n, 0));
        
        for(int i = 0; i < n; i++) {
            int temp = i;
            for(int j = i; j < n; j++) {
                if(arr.get(j) < arr.get(temp)) {
                    temp = j;
                }
                ans.set(temp, ans.get(temp) + 1);
            }
        }
        return ans;
    }

    // Driver Code
    public static void main(String[] args) {
        int N = 5;
        
        // Given array arr[]
        List<Integer> arr = Arrays.asList(3, 2, 4, 1, 5);
        
        // Function call
        List<Integer> a = countingSubarray(arr, N);
        
        System.out.print("[");
        int n = a.size() - 1;
        for(int i = 0; i < n; i++) {
            System.out.print(a.get(i) + ", ");
        }
        
        System.out.println(a.get(n) + "]");
    }
}

// Java program for the above approach
import java.util.*;

class GFG{
  
// Function to find the boundary of every 
// element within which it is minimum 
static int binaryInsert(ArrayList<Integer> boundary, 
                        int i) 
{ 
    int l = 0; 
    int r = boundary.size() - 1; 
  
    // Perform Binary Search 
    while (l <= r) 
    { 
      
        // Find mid m 
        int m = (l + r) / 2; 
  
        // Update l 
        if (boundary.get(m) < i) 
            l = m + 1; 
  
        // Update r 
        else
            r = m - 1; 
    } 
  
    // Inserting the index 
    boundary.add(l, i); 
  
    return l; 
} 
  
// Function to required count subarrays 
static int[] countingSubarray(int[] arr, 
                              int n) 
{ 
  
    // Stores the indices of element 
    Map<Integer, Integer> index = new HashMap<>(); 
    for(int i = 0; i < n; i++) 
        index.put(arr[i], i); 
  
    ArrayList<Integer> boundary = new ArrayList<>();
    boundary.add(-1);
    boundary.add(n); 

    Arrays.sort(arr);

    // Initialize the output array 
    int[] ans = new int[n];
  
    for(int num : arr) 
    { 
        int i = binaryInsert(boundary, 
                             index.get(num)); 
  
        // Left boundary, till the 
        // element is smallest 
        int l = boundary.get(i) -
                boundary.get(i - 1) - 1; 
  
        // Right boundary, till the 
        // element is smallest 
        int r = boundary.get(i + 1) -
                boundary.get(i) - 1; 
  
        // Calculate the number of subarrays 
        // based on its boundary 
        int cnt = l + r + l * r + 1; 
  
        // Adding cnt to the ans 
        ans[index.get(num)] += cnt; 
    } 
    return ans; 
}
  
// Driver code
public static void main (String[] args) 
{
    int N = 5; 
      
    // Given array arr[] 
    int[] arr = { 3, 2, 4, 1, 5 }; 
      
    // Function call 
    int[] a = countingSubarray(arr, N); 
      
    System.out.print("["); 
    int n = a.length - 1; 
    for(int i = 0; i < n; i++)  
        System.out.print(a[i] + ", "); 
          
    System.out.print(a[n] + "]"); 
}
}

// This code is contributed by offbeat

// Java implementation of the above approach
import java.util.*;
public class gfg
{
  // Function to required count subarrays
  static int[] countingSubarray(int arr[], int n)
  {

    // For storing count of subarrays
    int a[] = new int[n];

    // For finding next smaller 
    // element left to a element
    // if there is no next smaller 
    // element left to it than taking -1.
    int nsml[] = new int[n];
    Arrays.fill(nsml, -1);

    // For finding next smaller 
    // element right to a element
    // if there is no next smaller 
    // element right to it than taking n.
    int nsmr[] = new int[n];
    Arrays.fill(nsmr, n);

    Stack<Integer> st = new Stack<Integer>();
    for(int i = n - 1; i >= 0; i--) 
    {
      while (st.size() > 0 && 
             arr[(int)st.peek()] >= arr[i])
        st.pop();

      nsmr[i] = (st.size() > 0) ? (int)st.peek() : n;
      st.push(i);
    }
    while (st.size() > 0)
      st.pop();    
    for(int i = 0; i < n; i++) 
    {
      while (st.size() > 0 && 
             arr[(int)st.peek()] >= arr[i])
        st.pop();
      nsml[i] = (st.size() > 0) ? (int)st.peek() : -1;
      st.push(i);
    }
    for(int i = 0; i < n; i++) 
    {

      // Taking exact boundaries 
      // in which arr[i] is
      // minimum
      nsml[i]++;

      // Similarly for right side
      nsmr[i]--;
      int r = nsmr[i] - i + 1;
      int l = i - nsml[i] + 1;
      a[i] = r * l;
    }
    return a;
  }

  // Driver code
  public static void main(String[] args)
  {
    int N = 5;

    // Given array arr[]
    int arr[] = { 3, 2, 4, 1, 5 };

    // Function call
    int a[] = countingSubarray(arr, N);
    System.out.print("[");
    int n = a.length - 1;
    for(int i = 0; i < n; i++)
      System.out.print(a[i] + ", ");
    System.out.print(a[n] + "]");
  }
}

// This code is contributed by divyesh072019.