Skip to content
Related Articles

Related Articles

Count of all possible bitonic subarrays
  • Last Updated : 19 Jun, 2020

Given an array arr[] consisting of N integers, the task is to count all the subarrays which are Bitonic in nature.

A bitonic subarray is a subarray in which elements are either strictly increasing or strictly decreasing, or are first increasing and then decreasing.

Examples:

Input: arr[] = {2, 1, 4, 5}
Output: 8
Explanation:
All subarray which are bitonic in subarray are : {2}, {2, 1}, {1}, {1, 4}, {1, 4, 5}, {4}, {4, 5} and {5}.

Input: arr[] = {1, 2, 3, 4}
Output:10



Approach:
Follow the steps below to solve the problems:

  1. Generate all possible subarrays.
  2. For each subarray, check if it is bitonic or not. If the subarray is Bitonic then increment count for answer.
  3. Finally return the answer.

Below is the implementation of the above approach :

C++




// C++ program to count the
// number of possible
// bitonic subarrays
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the count
// of bitonic subarrays
void countbitonic(int arr[], int n)
{
    int c = 0;
    // Starting element of subarray
    for (int i = 0; i < n; i++) {
        // Ending element of subarray
        for (int j = i; j < n; j++) {
  
            int temp = arr[i], f = 0;
  
            // for 1 length
            if (j == i) {
                c++;
                continue;
            }
  
            int k = i + 1;
  
            // For increasing sequence
            while (temp < arr[k] && k <= j) {
                temp = arr[k];
                k++;
            }
  
            // If strictly increasing
            if (k > j) {
                c++;
                f = 2;
            }
  
            // For decreasing sequence
            while (temp > arr[k]
                   && k <= j
                   && f != 2) {
                temp = arr[k];
                k++;
            }
  
            if (k > j && f != 2) {
                c++;
                f = 0;
            }
        }
    }
  
    cout << c << endl;
}
// Driver Code
int main()
{
    int arr[] = { 1, 2, 4, 3, 6, 5 };
    int N = 6;
  
    countbitonic(arr, N);
}

Java




// Java program to count the number 
// of possible bitonic subarrays
import java.io.*; 
import java.util.*; 
  
class GFG{ 
      
// Function to return the count 
// of bitonic subarrays 
public static void countbitonic(int arr[], int n)
{
    int c = 0;
      
    // Starting element of subarray
    for(int i = 0; i < n; i++) 
    {
          
       // Ending element of subarray
       for(int j = i; j < n; j++) 
       {
          int temp = arr[i], f = 0;
            
          // For 1 length
          if (j == i)
          {
              c++;
              continue;
          }
          int k = i + 1;
            
          // For increasing sequence
          while (temp < arr[k] && k <= j)
          {
              temp = arr[k];
              k++;
          }
            
          // If strictly increasing
          if (k > j) 
          {
              c++;
              f = 2;
          }
            
          // For decreasing sequence
          while ( k <= j && temp > arr[k] && f != 2
          {
              temp = arr[k];
              k++;
          }
          if (k > j && f != 2)
          {
              c++;
              f = 0;
          }
       }
    }
    System.out.println(c);
}
  
// Driver code
public static void main(String[] args) 
    int arr[] = { 1, 2, 4, 3, 6, 5 };
    int N = 6;
      
    countbitonic(arr, N);
  
// This code is contributed by grand_master

Python3




# Python3 program to count the number 
# of possible bitonic subarrays
  
# Function to return the count 
# of bitonic subarrays 
def countbitonic(arr, n):
  
    c = 0;
      
    # Starting element of subarray
    for i in range(n):
          
        # Ending element of subarray
        for j in range(i, n): 
            temp = arr[i]
            f = 0;
  
            # For 1 length
            if (j == i) :
                c += 1
                continue;
            k = i + 1;
  
            # For increasing sequence
            while (temp < arr[k] and k <= j):
                temp = arr[k];
                k += 1
                  
            # If strictly increasing
            if (k > j) :
                c += 1
                f = 2;
                  
            # For decreasing sequence
            while (k <= j and temp > arr[k] and f != 2):
                temp = arr[k];
                k += 1;
                  
            if (k > j and f != 2):
                c += 1;
                f = 0;            
    print(c)
      
# Driver Code
arr = [ 1, 2, 4, 3, 6, 5 ];
N = 6;
  
countbitonic(arr, N);
  
# This code is contributed by grand_master

C#




// C# program to count the number 
// of possible bitonic subarrays 
using System;
  
class GFG{ 
  
// Function to return the count 
// of bitonic subarrays     
public static void countbitonic(int []arr, int n)
{
    int c = 0;
      
    // Starting element of subarray
    for(int i = 0; i < n; i++) 
    {
          
       // Ending element of subarray
       for(int j = i; j < n; j++)
       {
          int temp = arr[i], f = 0;
            
          // for 1 length
          if (j == i)
          {
              c++;
              continue;
          }
          int k = i + 1;
            
          // For increasing sequence
          while (temp < arr[k] && k <= j)
          {
              temp = arr[k];
              k++;
          }
            
          // If strictly increasing
          if (k > j)
          {
              c++;
              f = 2;
          }
            
          // For decreasing sequence
          while ( k <= j && temp > arr[k] && f != 2)
          {
              temp = arr[k];
              k++;
          }
          if (k > j && f != 2)
          {
              c++;
              f = 0;
          
       }
    }
    Console.Write(c);
}
  
// Driver code 
public static void Main() 
    int[] arr = { 1, 2, 4, 3, 6, 5 };
    int N = 6;
      
    countbitonic(arr, N);
  
// This code is contributed by grand_master
Output:
15

Time Complexity: O (N 3)
Auxiliary Space: O (1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up
Recommended Articles
Page :