Educational Codeforces Round 69 (Rated for Div. 2) B - Pillars

Educational Codeforces Round 69 (Rated for Div. 2)

 

B - Pillars

There are n pillars aligned in a row and numbered from 1 to n.

Initially each pillar contains exactly one disk. The i-th pillar contains a disk having radius ai.

You can move these disks from one pillar to another. You can take a disk from pillar i and place it on top of pillar j if all these conditions are met:

1. there is no other pillar between pillars i and j. Formally, it means that |i−j|=1;
2. pillar i contains exactly one disk;
3. either pillar j contains no disks, or the topmost disk on pillar j has radius strictly greater than the radius of the disk you move.

When you place a disk on a pillar that already has some disks on it, you put the new disk on top of previously placed disks, so the new disk will be used to check the third condition if you try to place another disk on the same pillar.

You may take any disk and place it on other pillar any number of times, provided that every time you do it, all three aforementioned conditions are met. Now you wonder, is it possible to place all n disks on the same pillar simultaneously?

Input

The first line contains one integer n (3≤n≤2⋅105) — the number of pillars.

The second line contains n integers a1, a2, ..., ai (1≤ai≤n), where ai is the radius of the disk initially placed on the i-th pillar. All numbers ai are distinct.

Output

Print YES if it is possible to place all the disks on the same pillar simultaneously, and NO otherwise. You may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).

Examples

input

4

1 3 4 2

output

YES

input

3

3 1 2

output

NO

Note

In the first case it is possible to place all disks on pillar 3 using the following sequence of actions:

1. take the disk with radius 3 from pillar 2 and place it on top of pillar 3;
2. take the disk with radius 1 from pillar 1 and place it on top of pillar 2;
3. take the disk with radius 2 from pillar 4 and place it on top of pillar 3;
4. take the disk with radius 1 from pillar 2 and place it on top of pillar 3.

 

题意：题目意思大概是有n个柱子，每个柱子上有ai个 磁盘，你可以进行无限次操作，把 第i个柱子的磁盘ai 移到 有aj磁盘的第j个柱子上，

当且仅当  1.  i，j柱子相邻 。2. i柱子上只有一个磁盘ai。 3. j柱子上没有磁盘 或 磁盘半径ai < aj 。

然后问你 最后能不能把所有磁盘移动到一个柱子上。

思路：既然要移到同一个柱子上，那磁盘半径从上到下肯定是从小到大，最下面的磁盘半径就要是最大的，

那我们可以先遍历一遍找到最大值下标，再从这里开始模拟放磁盘，左右的磁盘优先放大的，放不了就break。

最后判断是否叠了n个磁盘。

另外一种写法可以说是推论，也就是从这个最大值的位置开始，向左要全递减，向右也全递减，然后就是YES，否则就是NO。

因为向两边都递减，放磁盘一定是可以全放完的，可以仔细想一下。

 

写法一：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<queue>
using namespace std;
#define ll long long 
const int mod=1e9+7;
const int inf=1e9+7;
 
const int maxn=2e5+5;
int num[maxn];
 
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n;
    while(cin>>n)
    {
        int maxx=-1,mark_i;//标记最大值位置 

        for(int i=0;i<n;i++)
        {
            cin>>num[i];    
            if(num[i]>maxx)
            {
                maxx=num[i];
                mark_i=i;
            }
        }
        
        int left=mark_i-1;
        int right=mark_i+1;
        int now=num[mark_i];
        
        int cnt=1;//记录叠了几个磁盘 
        
        while(left>=0&&right<=n-1)//边界 
        {
            if(num[left]>=num[right])//左边大 
            {
                if(num[left]<=now)
                {
                    now=num[left];//向左延伸 
                    cnt++;
                    left--;
                }
                else if(num[left]>now)//不符合退出 
                {
                    break;
                }
            }
            else if(num[left]<num[right])//右边大 
            {
                if(num[right]<=now)
                {
                    now=num[right];//向右延伸 
                    right++;
                    cnt++;
                }
                else//不符合退出 
                {
                    break;
                }
            }
        }
        
        //可能两边有哪边没有延伸完，继续延伸 
        while(left>=0)
        {
            if(num[left]<=now)
            {
                now=num[left];
                cnt++;
                left--;
            }
            else if(num[left]>now)
            {
                break;
            }
        }
        
        while(right<=n-1)
        {
            if(num[right]<=now)
            {
                now=num[right];
                right++;
                cnt++;
            }
            else
            {
                break;
            }
        }
        
        if(cnt==n)//叠了n个磁盘 
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
        
    }
    
    return 0;
}

 

写法二：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<queue>
using namespace std;
#define ll long long 
const int mod=1e9+7;
const int inf=1e9+7;
 
const int maxn=2e5+5;
int num[maxn];
 
int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    int n;
    
    while(cin>>n)
    {
        int maxx=-1,mark_i;
        
        for(int i=0;i<n;i++)
        {
            cin>>num[i];
            
            if(num[i]>maxx)
            {
                maxx=num[i];
                mark_i=i;
            }
        }
        
        int flag=0;
        
        for(int i=mark_i;i>=1;i--)
        {
            if(num[i]<num[i-1])
            {
                flag=1;
                break;
            }
        }
        
        if(flag==0)
        {
            for(int i=mark_i;i<n-1;i++)
            {
                if(num[i]<num[i+1])
                {
                    flag=1;
                    break;
                }
            }
        }
        
        if(flag)
            cout<<"NO"<<endl;
        else
            cout<<"YES"<<endl;
    
    }
    
    return 0;
}