HDU 5532 Almost Sorted Array

最新推荐文章于 2019-08-22 16:39:58 发布

原创最新推荐文章于 2019-08-22 16:39:58 发布 · 175 阅读

1 ·

CC 4.0 BY-SA版权

动态规划专栏收录该内容

15 篇文章

订阅专栏

本文介绍了一种算法，用于判断一个数组是否可以通过删除一个元素变为递增或递减排序。通过两次遍历数组来检查是否满足条件，适用于竞赛编程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

传送门：HDU 5532

Almost Sorted Array Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others)

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

题意：
给你一个数组，请你判断他是否可以删除一个数后，满足递增或者递减的关系，如果可以输出YES，否则输出NO。

题解：
我们可以对一个数组正反搜两边，第一次搜递增，第二次搜递减。每次判断是否满足单调条件，不满足就记录次数，只有不满足的次数小于等于1的时候才可输出YES。

需要注意的是，遍历的时候不能简单的认为如果a[i]>a[i+1]不满足条件的一定是a[i+1]（递增的情况），有可能是因为a[i]太大的缘故，所以要分情况多搜一次。

如果要用dp做的话，就是正反两次求最长上升子序列，只要有一次长度>=n-1就行（要时间优化）。

AC代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int N=110000;
int t,n;
int a[N],b[N];
int main()
{
  scanf("%d",&t);
  while(t--)
  {
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
      scanf("%d",&a[i]);
    }
    for(int i=1;i<=n;i++)
    {
      b[i]=a[n-i+1];
    }
    a[n+1]=b[n+1]=inf;
    //递增
    int num1=0,flag=0;
    for(int i=1;i<n;i++)
    {
      if(a[i]<=a[i+1])
        continue;
      num1++;
      if(a[i]<=a[i+2]&&num1<=1)//a[i+1]为坏点 如 1 2 1 3 4
        continue;
      flag=1;
      break;
    }
    if(!flag)
    {
      printf("YES\n");
      continue;
    }
    int num2=0;
    flag=0;
    for(int i=1;i<n;i++)
    {
      if(a[i]<=a[i+1])
       continue;
      num2++;
      if(a[i-1]<=a[i+1]&&num2<=1)//a[i]为坏点 如：1 2 5 3 4 
        continue;
      flag=1;
      break;
    }
    if(!flag)
    {
      printf("YES\n");
      continue;
    }
    //递减
    num1=0;
    flag=0;
    for(int i=1;i<n;i++)
    {
      if(b[i]<=b[i+1])
        continue;
      num1++;
      if(b[i]<=b[i+2]&&num1<=1)
        continue;
      flag=1;
      break;
    }
    if(!flag)
    {
      printf("YES\n");
      continue;
    }
    num2=0;
    flag=0;
    for(int i=1;i<n;i++)
    {
      if(b[i]<=b[i+1])
       continue;
      num2++;
      if(b[i-1]<=b[i+1]&&num2<=1)
        continue;
      flag=1;
      break;
    }
    if(!flag)
    {
      printf("YES\n");
      continue;
    }
    printf("NO\n");//以上情况均不满足，则输出NO
  }
  return 0;
}

///                 .-~~~~~~~~~-._       _.-~~~~~~~~~-.
///             __.'              ~.   .~              `.__
///           .'//                  \./                  \\`.
///        .'//                      |                     \\`.
///       .'// .-~"""""""~~~~-._     |     _,-~~~~"""""""~-. \\`.
///     .'//.-"                 `-.  |  .-'                 "-.\\`.
///   .'//______.============-..   \ | /   ..-============.______\\`.
/// .'______________________________\|/______________________________`.