如何在复杂度 O(n) 中解决单调数组问题？答案

【问题标题】：How can Monotonic array problem be solved in Complexity O(n)?如何在复杂度 O(n) 中解决单调数组问题？
【发布时间】：2020-12-25 07:32:09
【问题描述】：

一个数组是单调递增或单调递减的。

例子：

输入：[1,2,2,3] 输出：真

输入：[3,2,2,1] 输出：真

输入：[1,3,2] 输出：假

这是我的 O(nlogn) 时间复杂度的代码。我使用排序和一个额外的数组来解决这个问题。我的代码如下：

    bool isMonotonic(vector<int> array) {


    vector<int>extraArray;
    int i,j;
    for(i=0;i<array.size();i++){
        extraArray.push_back(array[i]);
    }
    
    sort(extraArray.begin(),extraArray.end());
    
    for(i=0;i<array.size();i++){
        if(array[i] != extraArray[i])
            break;
    }
    if(i == array.size())
        return true;
    
    for(i = array.size() -1,j=0;j<extraArray.size();i--,j++){
        if(array[i] != extraArray[j])
            break;
    }
    if(j == extraArray.size())
        return true;
    
  return false;
}

如何在 O(n) 时间复杂度内解决？

【问题讨论】：

您尝试过一些更简单的方法吗？就像测试数组是否在增加一样。暂时忘记递减方面，也许灵感会来。

标签： c++ algorithm time-complexity

【解决方案1】：

这里是单调数组问题的 O(n) 代码。我们不需要首先使用另一个数组进行排序。在这里，我考虑了如果所有元素都相同，它仍然是单调的。

现在如果第二个元素比第一个大，如果整个数组需要按递增顺序排列，否则不能单调。如果第二个元素小于第一个元素，那么整个数组是否需要按降序排列。否则不是单调数组。

请注意，前两个元素可能相同，因此我们需要遍历数组以获取两个相邻元素之间的差异。

感谢您的提示。

bool isMonotonic(vector<int> array) {

    // O(n) time complexity | O(1) space complexity
    
    int i = 0, dif, temp;
            
    while(i+1 < array.size()){  //check until two adjacent elements are different 
     dif = array[i] - array[i+1];
        if(dif == 0)
            i++;
        else
            break;
    }
    
    if(dif == 0){ //all elements are same
        return true; 
    }
    else if(dif > 0){ //decreasing order test
        for( i = i; i+1 < array.size(); i++){
            temp = array[i] - array[i+1];
            if(temp < 0) // if order breaks, it's not monotonic
                break;
        }
    }else{ //dif < 0
        for( i = i; i+1 < array.size(); i++){ //check for increasing order
            temp = array[i] - array[i+1];
            if(temp > 0) //if order breaks, it's not monotonic
                break;
        }
    }
    if( i+1 == array.size() ) //order is maintained through the full array
        return true;
    
  return false;
}

【讨论】：

【解决方案2】：

您使用的策略是将数组排序为子步骤。使用标准排序算法需要时间 O(n log n)，这是代码中的瓶颈。问题是 - 你真的需要对数组进行排序吗？

作为提示，请查看前两个元素。如果第二个元素大于第一个元素，则数组单调的唯一方法是整个数组单调递增。你能检查一下是不是这样吗？如果第二个元素小于第一个元素，那么数组单调的唯一方法是整个数组单调递减。你能检查一下吗？如果前两个元素相等怎么办？

【讨论】：

【解决方案3】：

一些伪代码：

direction = None
for each element in array:
  if increasing(element, next element):
    if direction is decreasing then return false
    else if direction is None, let it be increasing
  else if decreasing(element, next element):
    if direction is increasing then return false
    else if direction is None, let it be decreasing

【讨论】：