INTUITION:

The problem is to determine whether the given array could be a non-decreasing, sorted array after at most one rotation. A rotated sorted array can have only one point where the order "breaks" or decreases. This means there can be at most one instance where a larger element is followed by a smaller one.

APPROACH:

• Count the breaks: Iterate through the array and count how many times the current element is larger than the next one. If this count is more than 1, the array cannot be a valid rotated sorted array.
• Boundary Case: After completing the traversal, if the first element is smaller than the last one, it indicates a rotation where the order breaks at the boundary. In this case, we increase the break count.
• Final Validation: If the total number of breaks is 1 or less, the array can be considered sorted with at most one rotation. Otherwise, it’s not possible.

Here’s the code:

class Solution {
public:
    bool check(vector<int>& nums) {
        int n=nums.size();
        int cnt=0;
        for(int i=1;i<n;i++){
            if(nums[i-1]>nums[i]){
                cnt++;
            }
        }
        if(nums[n-1]>nums[0])cnt++;
        if(cnt>1) return false;
        return true;
        
    }
};

KEYPOINTS:

• The key takeaway is understanding that a sorted and rotated array can have only one "break" point where the order is disrupted.
• By counting such breaks, we can efficiently determine whether the array meets the condition.

Feel free to share your approach and feedback in comment box.