thảo luận Leetcode + Codeforces, Competitive programming contest. Đường tới Guardian + Candidate Master.

class Solution {
    public long bowlSubarrays(int[] nums) {
        int[] reverse = new int[nums.length];
        for (int i = 0; i < nums.length; i += 1) {
            reverse[nums.length - 1 - i] = nums[i];
        }

        return count(nums) + countEqual(reverse);
    }

    public long countEqual(int[] nums) {
        int[] leftBigger = biggerFromLeftEqual(nums);
        int[] countSameEqual = counterSameNumber(nums);

        long answer = 0;
        int n = nums.length;
        for (int i = 0; i < n; i += 1) {
            int left = leftBigger[i];
            int countNumBigger = countSameEqual[left];

            if (i - left >= 2) {
                answer += countNumBigger;
            }
        }

        return answer;
    }

    public long count(int[] nums) {
        int[] leftBigger = biggerFromLeft(nums);
        int[] countSameEqual = counterSameNumber(nums);

        long answer = 0;
        int n = nums.length;
        for (int i = 0; i < n; i += 1) {
            int left = leftBigger[i];
            int countNumBigger = countSameEqual[left];

            if (i - left >= 2) {
                answer += countNumBigger;
            }
        }
        System.out.println(answer);

        return answer;
     
    }

    public int[] counterSameNumber(int[] nums) {
        int counter[] = new int[nums.length];
        counter[0] = 1;
        for (int i = 1; i < nums.length; i += 1) {
            if (nums[i] == nums[i - 1]) {
                counter[i] = counter[i - 1] + 1;
            } else {
                counter[i] = 1;
            }
        }

        return counter;
    }
 
    public int[] biggerFromLeftEqual(int[] nums) {
        int[] biggerFromLeft = new int[nums.length];
        Stack<Integer> decreaseOnly = new Stack<>();
        for (int i = 0; i < nums.length; i += 1) {
            while (!decreaseOnly.isEmpty() && nums[decreaseOnly.peek()] < nums[i]) {
                decreaseOnly.pop();
            }

            if (decreaseOnly.isEmpty()) {
                biggerFromLeft[i] = i;
            } else {
                biggerFromLeft[i] = decreaseOnly.peek();
            }

            decreaseOnly.add(i);
        }

        return biggerFromLeft;
    }
 
    public int[] biggerFromLeft(int[] nums) {
        int[] biggerFromLeft = new int[nums.length];
        Stack<Integer> decreaseOnly = new Stack<>();
        for (int i = 0; i < nums.length; i += 1) {
            while (!decreaseOnly.isEmpty() && nums[decreaseOnly.peek()] <= nums[i]) {
                decreaseOnly.pop();
            }

            if (decreaseOnly.isEmpty()) {
                biggerFromLeft[i] = i;
            } else {
                biggerFromLeft[i] = decreaseOnly.peek();
            }

            decreaseOnly.add(i);
        }

        return biggerFromLeft;
    }
}