HDU 5532 Almost Sorted Array

最新推荐文章于 2019-07-24 21:53:00 发布

原创最新推荐文章于 2019-07-24 21:53:00 发布 · 544 阅读

0 ·

CC 4.0 BY-SA版权

HDU 同时被 2 个专栏收录

3 篇文章

订阅专栏

1 篇文章

订阅专栏

本文介绍了一种高效算法，用于判断一个数组是否可以通过删除一个元素变为完全有序（升序或降序）。通过最长递增子序列（LIS）和最长递减子序列的计算，可以在O(n log n)的时间复杂度内完成这一任务。

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

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");

    }
}