Monotonic Array LT896

An array is monotonic if it is either monotone increasing or monotone decreasing.

An array A is monotone increasing if for all i <= j, A[i] <= A[j].  An array A is monotone decreasing if for all i <= j, A[i] >= A[j].

Return true if and only if the given array A is monotonic.

Example 1:

Input: [1,2,2,3]
Output: true

Example 2:

Input: [6,5,4,4]
Output: true

Example 3:

Input: [1,3,2]
Output: false

Example 4:

Input: [1,2,4,5]
Output: true

Example 5:

Input: [1,1,1]
Output: true

Note:

1. 1 <= A.length <= 50000
2. -100000 <= A[i] <= 100000

Idea 1. Check if it is monotonic increasing or decreasing, 需要2个pass, 自己曾想把这2个合二为一个pass, 才意识到有==, 序列开始可以是递增或递减

Time complexity: O(n), 2 scan

Space complexity: O(1)

 class Solution {
     private boolean isMonotonicIncreasing(int[] A) {
         int i = 1;
         while(i < A.length && A[i-1] <= A[i]) {
             ++i;
         }
         return i == A.length;
     }

     private boolean isMonotonicDecreasing(int[] A) {
         int i = 1;
         while(i < A.length && A[i-1] >= A[i]) {
             ++i;
         }
         return i == A.length;
     }

     public boolean isMonotonic(int[] A) {
         return isMonotonicIncreasing(A) || isMonotonicDecreasing(A);
     }
 }

反着想，有递增pair就不是递减

 class Solution {
     private boolean isMonotonicIncreasing(int[] A) {
         for(int i = 1; i < A.length; ++i) {
             if(A[i-1] > A[i]) {
                 return false;
             }
         }
         return true;
     }

     private boolean isMonotonicDecreasing(int[] A) {
         for(int i = 1; i < A.length; ++i) {
             if(A[i-1] < A[i]) {
                 return false;
             }
         }
         return true;
     }

     public boolean isMonotonic(int[] A) {
         return isMonotonicIncreasing(A) || isMonotonicDecreasing(A);
     }
 }

Idea 1.b. Similar to Longest Turbulent Subarray LT978, store the sign and return false if current sign is opposite to previous sign.

Time complexity: O(n)

Space complexity: O(1)

 class Solution {

     public boolean isMonotonic(int[] A) {
         int flag = 0;
         for(int i = 1; i < A.length; ++i) {
             int c = Integer.compare(A[i-1], A[i]);
             if(c == 0) {
                 continue;
             }

             if(flag != 0 && c != flag) {
                 return false;
             }
             flag = c;
         }

         return true;
     }
 }

Idea 1.c 如果同时有decreasing and increasing pair, 肯定不是monotonic

 class Solution {
     public boolean isMonotonic(int[] A) {
        boolean increasing = false;
        boolean decreasing = false;
        for(int i = 1; i < A.length; ++i) {
            if(A[i-1] > A[i]) {
                increasing = true;
            }
            else if(A[i-1] < A[i]) {
                decreasing = true;
            }
        }

        if(increasing && decreasing) {
            return false;
        }

        return true;
     }
 }

官方的妙法，反着来， 注意上面的解法直接return increasing^decreasing不行，考虑数组全是==， 官方的这个考虑到了，就是想法有些绕

 class Solution {
     public boolean isMonotonic(int[] A) {
        boolean increasing = true;
        boolean decreasing = true;
        for(int i = 1; i < A.length; ++i) {
            if(A[i-1] < A[i]) {
                increasing = false;
            }
            else if(A[i-1] > A[i]) {
                decreasing = false;
            }
        }

        return increasing || decreasing;
     }
 }