Question

我尝试在CodeFights上解决这个挑战，但是，它并没有起作用。我最好的解决方案得到了25/26（上次测试超过了时间限制），但我删除了因为我昨天尝试了它（它是O（n ^ 2））。现在我在O（n）中尝试了一个新的。我很累，今天我真的很想完成这件事，所以请帮助我。

以下是陈述：给定一个整数序列作为数组，通过从数组中删除不超过一个元素来确定是否可以获得严格增加的序列。

实施例

#include <iostream>
#include <vector>

#include <algorithm>

bool almostIncreasingSequence(std::vector<int> sequence) 
{
    int count = 0;


    for(int i = 0; i < sequence.size()-1; i++)
    {
        if(sequence[i] > sequence[i+1])
        {
            count++;
            sequence.erase(sequence.begin(), sequence.begin() + i);
            i--;
        }
        if(count == 2)
            return false;
    }
    return true;
}

int main()
{
    std::cout << std::endl;
    return 0;
}

这是我的代码，直到现在......（代码很差）：

{{1}}

Answer 1

这是一个带有O（N）运行时的C ++ 11解决方案：

constexpr auto Max = std::numeric_limits<std::size_t>::max();
bool is_sorted_but_skip(const std::vector<int>& vec, std::size_t index = Max){
    auto Start = index == 0 ? 1 : 0;
    auto prev = vec[Start];
    for(std::size_t i = Start + 1; i < vec.size(); i++){
        if(i == index) continue;
        if(prev >= vec[i]) return false;
        prev = vec[i];
    }
    return true;
}

bool almostIncreasingSequence(std::vector<int> v) 
{
    auto iter = std::adjacent_find(v.begin(), v.end(), [](int L, int R){ return L >= R; });
    if(is_sorted_but_skip(v, std::distance(v.begin(), iter)))
        return true;
    return is_sorted_but_skip(v, std::distance(v.begin(), std::next(iter)));
}

我们使用std::adjacent_find来查找第一个元素iter大于或等于其下一个元素。然后我们检查序列是否在跳过iter的位置时严格排序。

否则，我们会在跳过iter+1的位置时检查序列是否严格排序

更糟糕的案例复杂性：3线性扫描

Demo

Answer 2

这仍然是O（N ^ 2），因为您在每次迭代中删除了向量的第一个元素。不要删除第一个元素，不要在循环中i--。

如果你必须删除号码（你不是，但仍然），至少从列表的末尾开始。这样擦除一个数字可能是一个O（1）操作（我不是100％确定＆＃39; s如何实现std :: vector）。

你真的不必删除数字。

Answer 3

这是一个提示（好吧，几乎是一个解决方案）：

如果您看到一个元素与下一个元素之间的减少，那么您必须删除其中一个元素（*）。

现在，如果你发现两个不相交的元素对之间有两个减少怎么办？那是对的： - ）

记住这一点，您应该能够使用线性扫描和一些恒定时间的工作来解决您的问题。

_{（*）不包括第一对和最后一对元素。}

Answer 4

Comparator<Student> comparator=new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                if(o1.roll<=o2.roll)
                    return -1;
                else return 1;
            }
        };
        TreeMap<Integer, Student> map=new TreeMap<>(comparator);

增加序列C ++

4 个答案: