Java几乎递增序列

好吧，我刚开始进行代码战，我有个问题：

经过几个小时的努力，我自己想办法解决它，我得到了它的全部功能，但显然它没有在时间限制内，我不知道如何修复它，甚至更解决它

boolean almostIncreasingSequence(int[] sequence) {
    List<Integer> A = new ArrayList<Integer>();
    for (int i = 0; i < sequence.length; i++){
        A.add(sequence[i]);
    }
    for (int i = 0; i < A.size(); i++){
        ArrayList<Integer> AC = new ArrayList<Integer>(A);
        AC.remove(i);
        boolean ps = true;
        for (int x = 0; x < AC.size()-1; x++){
            if (AC.get(x) >= AC.get(x+1)){
                ps = false;
                break;
            }
        }
        if (ps){
            return true;
        }
    }
    return false;
}

布尔几乎递增序列（int[]序列）{
列表A=新的ArrayList（）；
for（int i=0；i=AC.get（x+1））{
ps=假；
打破
}
}
如果（ps）{
返回true；
}
}
返回false；
}

这就是我得到的

---

我知道有这样的问题，但我还没有找到解决办法。我希望有人能帮忙。我已经在这个问题上坚持了几个小时。

你可能需要考虑另一种方法来解决这个问题。通过对每个条目进行一次评估，可以在线性时间内解决此问题。条目可以是递增序列的一部分，也可以是几乎递增序列的一部分，或者两者都不是

如果一个序列包含少于两个几乎递增的条目，那么它将几乎递增，所以我们可以在最后简单地检查一下

public enum EntryState {
    INCREASING(0), ALMOST_INCREASING(1), DECREASING(2);

    private final int state;
    private EntryState(int state) {
        this.state = state;
    }
    public int getValue() { return state; }
}

public boolean almostIncreasingSequence(int[] sequence) {
    int l = sequence.length;
    EntryState[] sequenceState = new EntryState[l];
    for(int i = 0; i < l - 1; i++) {
        if(sequence[i] <= sequence[i + 1])
            sequenceState[i] = EntryState.INCREASING;
        else if((i + 2 >= l) || (i + 2 < l && sequence[i] <= sequence[i + 2]))
            sequenceState[i] = EntryState.ALMOST_INCREASING;
        else
            sequenceState[i] = EntryState.DECREASING;
    }
    sequenceState[l - 1] = EntryState.INCREASING;

    int sum = 0;
    for(EntryState e : sequenceState)
        sum += e.getValue();

    int sumWithoutStart = sum - sequenceState[0].getValue();
    int sumWithoutEnd = sum - sequenceState[l - 1].getValue();
    return sumWithoutStart == 0 || sumWithoutEnd == 0 || sum < 2;
}

公共枚举入口状态{
增加（0），几乎增加（1），减少（2）；
私人国家；
私有入口状态（int状态）{
this.state=状态；
}
public int getValue（）{return state；}
}
公共布尔值几乎递增序列（int[]序列）{
int l=序列长度；
EntryState[]sequenceState=新的EntryState[l]；
对于（int i=0；i如果（序列[i]＝L）*（i＋2＜L & &序列[i] < p>），你可能需要考虑另一种方法来解决这个问题。这个问题可以在线性时间内通过对每个条目进行一次评估来解决。一个条目可以是一个递增序列的一部分，是一个几乎递增序列的一部分，或者两者都不是。
如果一个序列包含少于两个几乎递增的条目，那么它将几乎递增，所以我们可以在最后简单地检查一下

public enum EntryState {
    INCREASING(0), ALMOST_INCREASING(1), DECREASING(2);

    private final int state;
    private EntryState(int state) {
        this.state = state;
    }
    public int getValue() { return state; }
}

public boolean almostIncreasingSequence(int[] sequence) {
    int l = sequence.length;
    EntryState[] sequenceState = new EntryState[l];
    for(int i = 0; i < l - 1; i++) {
        if(sequence[i] <= sequence[i + 1])
            sequenceState[i] = EntryState.INCREASING;
        else if((i + 2 >= l) || (i + 2 < l && sequence[i] <= sequence[i + 2]))
            sequenceState[i] = EntryState.ALMOST_INCREASING;
        else
            sequenceState[i] = EntryState.DECREASING;
    }
    sequenceState[l - 1] = EntryState.INCREASING;

    int sum = 0;
    for(EntryState e : sequenceState)
        sum += e.getValue();

    int sumWithoutStart = sum - sequenceState[0].getValue();
    int sumWithoutEnd = sum - sequenceState[l - 1].getValue();
    return sumWithoutStart == 0 || sumWithoutEnd == 0 || sum < 2;
}

公共枚举入口状态{
增加（0），几乎增加（1），减少（2）；
私人国家；
私有入口状态（int状态）{
this.state=状态；
}
public int getValue（）{return state；}
}
公共布尔值几乎递增序列（int[]序列）{
int l=序列长度；
EntryState[]sequenceState=新的EntryState[l]；
对于（int i=0；i如果（sequence[i]=l）| |（i+2
public static void main( String[] args )
{
    System.out.println( "Output: " + almostIncreasingSequence( new int[]{1,3,2,1} ) );
    System.out.println("\r\n");
    System.out.println( "Output: " + almostIncreasingSequence( new int[]{1,3,2} ) ) ;
    System.out.println("\r\n");
    System.out.println( "Output: " + almostIncreasingSequence( new int[]{1,3,5,12,15,2} ) );
}

public static boolean almostIncreasingSequence( int[] array )
{
    boolean hasIncreasingSequenceNature = false;
    for( int x = 0; x < array.length; x++ )
    {
        boolean almostIncreasingWithRemovedElement = assumeRemovedElement(x , array);
        System.out.println( "Removing " + array[x] + " would produce INCREASING SEQUENCE?: " + almostIncreasingWithRemovedElement);
        if( almostIncreasingWithRemovedElement )
        {
            hasIncreasingSequenceNature = true;
        }               
    }
    return hasIncreasingSequenceNature;
}

public static boolean assumeRemovedElement( int assumeRemovedIndex , int[] data )
{
    boolean isIncreasing = false;
    for( int x = 0; x < data.length - 1; x++ )
    {
        if( x == ( assumeRemovedIndex - 1 ) )
        {
            if( (x < data.length - 2 ) )
            {
                if( data[x] < data[x + 2] )
                {
                    isIncreasing = true;
                }
                else
                {
                    isIncreasing = false;
                    break;
                }
            }
        }
        else if( x != assumeRemovedIndex )
        {
            if( data[x] < data[x + 1] )
            {
                isIncreasing = true;
            }
            else
            {
                isIncreasing = false;
                break;
            }               
        }
    }
    return isIncreasing;
}

publicstaticvoidmain（字符串[]args）
{
println（“输出：+almostIncreasingSequence（新的int[]{1,3,2,1}））；
System.out.println（“\r\n”）；
System.out.println（“输出：+almostIncreasingSequence（新的int[]{1,3,2}））；
System.out.println（“\r\n”）；
println（“输出：+almostIncreasingSequence（新的int[]{1,3,5,12,15,2}））；
}
公共静态布尔值几乎递增序列（int[]数组）
{
布尔hasIncreasingSequenceNature=false；
对于（int x=0；x

我想你混淆的部分是从数组中删除元素，但这并不要求你实际尝试从数组中删除内容，而是找到一种迭代方法，帮助你跳过假定的删除元素，让代码跟踪不断增加的序列在数组中，在迭代过程中

在解释代码时，布尔几乎递增序列（int[]）实际上什么都不做，只是对列表中的每个元素进行了一次蛮力式的尝试，看看如何假定RemovedElement（int byIndex，int[]yourSequence）当应用递增序列检查算法时，通过使用byIndex变量跳过数组元素返回。一旦我们发现assumeRemovedElement（int，int[]）返回true，几乎递增序列（int[]）将其hasIncreasingSequenceNature标记为true或false，以便可以分析最终输出，因为请记住，必须通过检查序列，假设移除数组中的每个元素，因此称为暴力

assumeRemovedElement（int-assumeRemovedIndex，int[]数据）在数组中的递增序列