HDU 5532 Almost Sorted Array

Almost Sorted Array

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 2136    Accepted Submission(s): 537

Problem Description

We are all familiar with sorting algorithms: quick sort, merge sort, heap sort, insertion sort, selection sort, bubble sort, etc. But sometimes it is an overkill to use these algorithms for an almost sorted array.

We say an array is sorted if its elements are in non-decreasing order or non-increasing order. We say an array is almost sorted if we can remove exactly one element from it, and the remaining array is sorted. Now you are given an array a1,a2,…,an, is it almost sorted?

 

Input

The first line contains an integer T indicating the total number of test cases. Each test case starts with an integer n in one line, then one line with n integers a1,a2,…,an.

1≤T≤2000
2≤n≤105
1≤ai≤105
There are at most 20 test cases with n>1000.

 

Output

For each test case, please output "`YES`" if it is almost sorted. Otherwise, output "`NO`" (both without quotes).

 

Sample Input

3 3 2 1 7 3 3 2 1 5 3 1 4 1 5

 

Sample Output

YES YES NO

 

Source

2015ACM/ICPC亚洲区长春站-重现赛（感谢东北师大）

 

Recommend

hujie   |   We have carefully selected several similar problems for you:  5701 5700 5699 5698 5697 

 

方法一：

解：当时首先想到的是用O(n)的思路答，每次遇到逆序的就选择一个删掉，具体选择思路：比如求上升时，若a[i]<a[i-1]，那么肯定要删除a[i]或者a[i-1]。那么如果a[i]>a[i-2]则删除a[i-1]，否则删除a[i]；看最终删除的次数来判断。

方法2：

直接用nlogn的方法求最长上升子序列和最长下降子序列的长度，如果大于等于n-1则YES。

关于nlogn求LIS的方法。用一个D[]的数组来辅助，D[i]表示LIS为i时结尾数字最小时多少。可知D[]数组是一个递增数组，所以LIS的循环中可以用一个二分来查找比a[j]小且LIS最大是多少，求出之后维护D数组，最后的时间复杂度就是nlogn。

<pre name="code" class="cpp">#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 100005
using namespace std;
int a[maxn];
int d[maxn];
int dp[maxn];
int find(int l,int r,int val)
{
    int ans;
    int mid;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(d[mid]<=val)
        {
            ans=mid;
            l=mid+1;
        }
        else {
            r=mid-1;
        }
    }
    return ans;
}
int LIS(int n)
{
    int now;
    int maxx=0;    memset(d,0,sizeof(d));
    d[0]=-1000000000;
    for(int i=1;i<=n;i++)
    {
       // if(a[i]>d[maxx])
        //{
          //  maxx++;
            //d[maxx]=a[i];
        //}
        //else {
            now=find(0,maxx,a[i]);
            d[now+1]=a[i];
            maxx=max(maxx,now+1);
        //}
    }
    return maxx;
}
int main()
{
    int flag1,flag2;
    int n,T;
    scanf("%d",&T);
    while(T--)
    {
        flag1=0;flag2=0;

        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        flag1=LIS(n);
        for(int i=1;i<=n/2;i++)
        {
            swap(a[i],a[n-i+1]);
        }
        flag2=LIS(n);
        if(flag1>=n-1||flag2>=n-1)
            printf("YES\n");
        else printf("NO\n");

    }
}