力扣896 单调数列（异或法）

原题：896. 单调数列

如果数组是单调递增或单调递减的，那么它是单调的。

如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。

当给定的数组 A 是单调数组时返回 true，否则返回 false。

提示：

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

网上很多人采用的是多情况讨论法，同时讨论大于和小于的情况，比如计数等等，在这里我采用了异或的方法，即找到两个下标i和j，如果A[i]?A[i-1] 和 A[j]?A[j-1] 的两个？（=，<或>）是异号（一个是大于一个是小于），那么就不是单调的。i为A中第一个不等于前一个元素的下标，即在i之前的下标k，都满足A[k]==A[k-1]，而A[i]>A[i-1]或者A[i]<A[i-1]，j初始化为i+1，遍历判断A[j]与A[j-1]的大小与符号情况。具体情况如下表所示：

A[i]?A[i-1]	A[j]?A[j-1]	判断
>	<	不单调
>	>	继续判断j+1
>	=	继续判断j+1
<	<	继续判断j+1
<	>	不单调
<	=	继续判断j+1

 

判断符号情况我想到了两种方法：做差法和判断大于（或小于）法。

1.做差法即令A[i]-A[i-1]与A[j]-A[j-1]结果相乘，如果小于0，说明两者其中一个小于0，一个大于0，意味着A[i]>A[i-1]且A[j]<A[j-1]或者A[i]<A[i-1]且A[j]>A[j-1]两种情况，那么数列不再单调，直接return false；如果等于0，代表A[j]=A[j-1]，不能判断是否单调，此时j需要右移，如果大于0，意味着A[i]>A[i-1]且A[j]>A[j-1]或者A[i]<A[i-1]且A[j]<A[j-1]两种情况，保证了A[0]到A[j]是单调的，j右移继续判断。

class Solution {
public:
    bool isMonotonic(vector<int>& A) {
        int n=A.size();
        if(n==1){
            return true;
        }
        int i=1;
        while((i<n) && (A[i-1]==A[i])) i++;//找到第一个纯增/减
        for(int j=i+1;j<n;j++){
            if((A[j-1]-A[j])*(A[i-1]-A[i])<0){
                return false;
            }
        }
        return true;
    }
};

但是计算加减和乘除需要时间比较慢。

2.判断大于（或小于）法。以判断大于为例，运用异或：

判断A[i]>A[i-1]	判断A[j]>A[j-1]	异或结果
true	true	false
true	false	true
false	true	true
false	false	false

而判断非单调的条件是A[i]>A[i-1]与A[j]>A[j-1]不等，分别为true、false或false、true两种情况，对应他们的异或为true（判断前首先判断A[j]是否等于A[j-1]，若等于则跳过）

因此，运用异或(^)的代码为：

class Solution {
public:
    bool isMonotonic(vector<int>& A) {
        int n=A.size();
        if(n==1){
            return true;
        }
        int i=1;
        while((i<n) && (A[i-1]==A[i])) i++;//找到第一个纯增/减
        for(int j=i+1;j<n;j++){
            if (A[j-1]!=A[j]){
                if(((A[j-1]<A[j])^(A[i-1]<A[i]))==true){
                    return false;
                }                
            }

        }
        return true;
    }
};

或者直接判断A[i]>A[i-1] ！= A[j]>A[j-1]

class Solution {
public:
    bool isMonotonic(vector<int>& A) {
        int n=A.size();
        if(n==1){
            return true;
        }
        int i=1;
        while((i<n) && (A[i-1]==A[i])) i++;//找到第一个纯增/减
        for(int j=i+1;j<n;j++){
            if (A[j-1]!=A[j]){
                if((A[j-1]<A[j])!=(A[i-1]<A[i])){
                    return false;
                }                
            }

        }
        return true;
    }
};

但是两者的运行时间似乎相同。

总而言之，这样的方法能避免出现if(大于等于) else 情况，并且能够提前终止，但是目前执行时间最快的是使用swich-case。