2058. Find the Minimum and Maximum Number of Nodes Between Critical Points

class Solution {
    public int[] nodesBetweenCriticalPoints(ListNode head) {
        List<Integer> criticalPoints = new ArrayList<>();
        
        ListNode prev = head;
        ListNode curr = head.next;
        int index = 1;
        
        while (curr.next != null) {
            // Local maxima: curr > prev AND curr > next
            // Local minima: curr < prev AND curr < next
            if ((curr.val > prev.val && curr.val > curr.next.val) ||
                (curr.val < prev.val && curr.val < curr.next.val)) {
                criticalPoints.add(index);
            }
            prev = curr;
            curr = curr.next;
            index++;
        }
        
        // Fewer than 2 critical points
        if (criticalPoints.size() < 2) {
            return new int[]{-1, -1};
        }
        
        int minDist = Integer.MAX_VALUE;
        int maxDist = criticalPoints.get(criticalPoints.size() - 1) 
                    - criticalPoints.get(0);
        
        // Min distance is always between consecutive critical points
        for (int i = 1; i < criticalPoints.size(); i++) {
            minDist = Math.min(minDist, 
                      criticalPoints.get(i) - criticalPoints.get(i - 1));
        }
        
        return new int[]{minDist, maxDist};
    }
}

class Solution:
    def nodesBetweenCriticalPoints(self, head):
        critical_points = []

        prev = head
        curr = head.next
        index = 1

        while curr.next:
            if ((curr.val > prev.val and curr.val > curr.next.val) or
                (curr.val < prev.val and curr.val < curr.next.val)):
                critical_points.append(index)

            prev = curr
            curr = curr.next
            index += 1

        if len(critical_points) < 2:
            return [-1, -1]

        min_dist = float('inf')
        max_dist = critical_points[-1] - critical_points[0]

        for i in range(1, len(critical_points)):
            min_dist = min(
                min_dist,
                critical_points[i] - critical_points[i - 1]
            )

        return [min_dist, max_dist]

class Solution {
public:
    vector<int> nodesBetweenCriticalPoints(ListNode* head) {
        vector<int> criticalPoints;

        ListNode* prev = head;
        ListNode* curr = head->next;
        int index = 1;

        while (curr->next != nullptr) {
            if ((curr->val > prev->val && curr->val > curr->next->val) ||
                (curr->val < prev->val && curr->val < curr->next->val)) {
                criticalPoints.push_back(index);
            }

            prev = curr;
            curr = curr->next;
            index++;
        }

        if (criticalPoints.size() < 2) {
            return {-1, -1};
        }

        int minDist = INT_MAX;
        int maxDist = criticalPoints.back() - criticalPoints.front();

        for (int i = 1; i < criticalPoints.size(); i++) {
            minDist = min(
                minDist,
                criticalPoints[i] - criticalPoints[i - 1]
            );
        }

        return {minDist, maxDist};
    }
};

class Solution {
    nodesBetweenCriticalPoints(head) {
        const criticalPoints = [];

        let prev = head;
        let curr = head.next;
        let index = 1;

        while (curr.next !== null) {
            if (
                (curr.val > prev.val && curr.val > curr.next.val) ||
                (curr.val < prev.val && curr.val < curr.next.val)
            ) {
                criticalPoints.push(index);
            }

            prev = curr;
            curr = curr.next;
            index++;
        }

        if (criticalPoints.length < 2) {
            return [-1, -1];
        }

        let minDist = Infinity;
        const maxDist =
            criticalPoints[criticalPoints.length - 1] -
            criticalPoints[0];

        for (let i = 1; i < criticalPoints.length; i++) {
            minDist = Math.min(
                minDist,
                criticalPoints[i] - criticalPoints[i - 1]
            );
        }

        return [minDist, maxDist];
    }
}