最小和最大值相同的子数组数

给定一个由n个整数组成的数组，请找到最小和最大元素相同的子数组。子数组定义为连续元素的非空序列。

例子 ：

Input: 2 3 1 1 
Output: 5
Explanation: The subarrays are (2), 
(3), (1), (1) and (1, 1) 

Input: 2 4 5 3 3 3
Output: 9
Explanation: The subarrays are (2), (4), 
(5), (3), (3, 3), (3, 3, 3), (3), (3, 3) and 
(3) 

首先要观察的是，只有那些所有元素都相同的子数组才具有相同的最小值和最大值。具有不同的元素显然意味着不同的最小和最大。因此，我们只需要计算连续的相同元素的数量(例如d) ，然后通过组合公式，得出子数组的个数为–

No of subarrays possible with d elements = ( d * (d+1) / 2 )
where d is number of continuous same elements.

我们从1-n遍历，然后从I + 1遍历到n，然后找到连续的相同元素的数量，然后将可能的子数组添加到结果中。

C++

// CPP program to count number of subarrays 
// having same minimum and maximum.
#include 
using namespace std;
  
// calculate the no of contiguous subarrays
// which has same minimum and maximum
int calculate(int a[], int n)
{
    // stores the answer
    int ans = 0;
  
    // loop to traverse from 0-n
    for (int i = 0; i < n; i++) {
  
        // start checking subarray from next element
        int r = i + 1;
  
        // traverse for finding subarrays
        for (int j = r; j < n; j++) {
  
            // if the elements are same then 
            // we check further and keep a count
            // of same numbers in 'r'
            if (a[i] == a[j])
                r += 1; 
            else
                break; 
        }
  
        // the no of elements in between r and i
        // with same elements.
        int d = r - i;
  
        // the no of subarrays that can be formed 
        // between i and r
        ans += (d * (d + 1) / 2);
  
        // again start checking from the next index
        i = r - 1;
    }
  
    // returns answer
    return ans;
}
  
// drive program to test the above function
int main()
{
    int a[] = { 2, 4, 5, 3, 3, 3 };
    int n = sizeof(a) / sizeof(a[0]);
    cout << calculate(a, n);
    return 0;
}

Java

// Java program to count number of subarrays 
// having same minimum and maximum.
  
class Subarray 
{
    // calculate the no of contiguous subarrays
    // which has same minimum and maximum
    static int calculate(int a[], int n)
    {
        // stores the answer
        int ans = 0;
  
        // loop to traverse from 0-n
        for (int i = 0; i < n; i++) {
  
            // start checking subarray from
            // next element
            int r = i + 1;
  
            // traverse for finding subarrays
            for (int j = r; j < n; j++) {
  
                // if the elements are same then 
                // we check further and keep a 
                // count of same numbers in 'r'
                if (a[i] == a[j])
                    r += 1; 
                else
                    break; 
            }
  
            // the no of elements in between r 
            // and i with same elements.
            int d = r - i;
  
            // the no. of subarrays that can be 
            // formed between i and r
            ans += (d * (d + 1) / 2);
  
            // again start checking from the next
            // index
            i = r - 1;
        }
  
        // returns answer
        return ans;
    }
      
    // Driver program to test above functions
    public static void main(String[] args) 
    {
    int a[] = {  2, 4, 5, 3, 3, 3 };
    System.out.println(calculate(a, a.length));
    }
}
// This code is contributed by Prerna Saini

Python3

# Python3 program to count 
# number of subarrays having 
# same minimum and maximum.
  
# calculate the no of contiguous 
# subarrays which has same 
# minimum and maximum
def calculate(a, n):
      
    # stores the answer
    ans = 0;
    i = 0;
  
    # loop to traverse from 0-n
    while(i < n): 
          
        # start checking subarray 
        # from next element
        r = i + 1;
  
        # traverse for
        # finding subarrays
        for j in range(r, n): 
              
            # if the elements are same 
            # then we check further 
            # and keep a count of same 
            # numbers in 'r'
            if (a[i] == a[j]):
                r = r + 1; 
            else:
                break; 
  
        # the no of elements in 
        # between r and i with
        # same elements.
        d = r - i;
  
        # the no of subarrays that 
        # can be formed between i and r
        ans = ans + (d * (d + 1) / 2);
  
        # again start checking 
        # from the next index
        i = r - 1;
        i = i + 1;
  
    # returns answer
    return int(ans);
  
# Driver Code
a = [ 2, 4, 5, 3, 3, 3 ];
n = len(a);
print(calculate(a, n));
  
# This code is contributed by mits

C#

// Program to count number
// of subarrays having same
// minimum and maximum.
using System;
  
class Subarray {
    // calculate the no of contiguous
    // subarrays which has the same
    // minimum and maximum
    static int calculate(int[] a, int n)
    {
        // stores the answer
        int ans = 0;
  
        // loop to traverse from 0-n
        for (int i = 0; i < n; i++) {
  
            // start checking subarray
            // from next element
            int r = i + 1;
  
            // traverse for finding subarrays
            for (int j = r; j < n; j++) {
  
                // if the elements are same then
                // we check further and keep a
                // count of same numbers in 'r'
                if (a[i] == a[j])
                    r += 1;
                else
                    break;
            }
  
            // the no of elements in between
            // r and i with same elements.
            int d = r - i;
  
            // the no. of subarrays that can
            // be formed between i and r
            ans += (d * (d + 1) / 2);
  
            // again start checking from
            // the next index
            i = r - 1;
        }
  
        // returns answer
        return ans;
    }
  
    // Driver program
    public static void Main()
    {
        int[] a = { 2, 4, 5, 3, 3, 3 };
        Console.WriteLine(calculate(a, a.Length));
    }
}
  
// This code is contributed by Anant Agarwal.

输出 ：

9

时间复杂度： O(n ^ 2)
辅助空间： O(1)