根据给定条件检查是否所有磁盘都可以放在单个杆上

给定一个数组nrr [] ，该数组arr []由代表N个杆的N个整数组成，每个半径为arr [i]的圆盘，任务是根据在i处的圆盘的条件，检查是否可以将所有圆盘移动到单个杆^个杆可以移动到^第j^个杆仅当：

• abs (i – j)= 1 ，^第i^个杆只有一个磁盘。
• 第i^个杆的圆盘半径小于第j^个杆的顶圆盘，或者第j^个杆为空。

例子：

Input: arr[] = {1, 3, 5, 2}, N = 4
Output: YES
Explanation:
One of the possible ways is:
First move the disk of radii 3 at rod 2 to the top of rod 3. 
The array arr[] modifies to {1, 0, (5, 3), 2}.
Move the disk of radii 2 at rod 4 to the top of rod 3. The array arr[] modifies to {1, 0, (5, 3, 2), 0}.
Move the disk of radii 1 at rod 1 to top of the rod 2. The array arr[] modifies to {0, 1, (5, 3, 2), 0}.
Now, move the disk of radii 1 at rod 2 to the top of rod 3. The array arr[] modifies to {0, 0, (5, 3, 2, 1), 0}.

Input: arr[] = {4, 1, 2}, N = 3
Output: NO

方法：可以根据以下观察结果解决给定问题：

• It can be observed that if there exists an index i such that arr[i] < arr[i – 1] and arr[i] < arr[i + 1], then it is impossible to move all the disks at a single rod.
• Therefore, the task is reduced to finding if there exists any index i such that arr[i] < arr[i – 1] and arr[i] < arr[i + 1].

请按照以下步骤解决问题：

• 初始化一个变量，例如flag = false ，以存储数组中是否存在这样的索引。
• 在索引[1，N – 2]上遍历数组。对于每个^第i^个索引，检查arr [i] ，然后将flag设置为true并中断。
• 如果标志为false，则打印“ YES” 。否则，打印“否” 。

下面是上述方法的实现：

C++

// C++ implementation of above approach
#include 
using namespace std;
 
// Function to check if it is possible
// to move all disks to a single rod
bool check(int a[], int n)
{
    // Stores if it is possible to move
    // all disks to a single rod
    bool flag = 0;
 
    // Traverse the array
    for (int i = 1; i < n - 1; i++) {
 
        // If i-th element is smaller than
        // both its adjacent elements
        if (a[i + 1] > a[i]
            && a[i] < a[i - 1])
            flag = 1;
    }
 
    // If flag is true
    if (flag)
        return false;
 
    // Otherwise
    else
        return true;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 3, 5, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    if (check(arr, N))
        cout << "YES";
    else
        cout << "NO";
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG
{
 
// Function to check if it is possible
// to move all disks to a single rod
static boolean check(int a[], int n)
{
   
    // Stores if it is possible to move
    // all disks to a single rod
    boolean flag = false;
 
    // Traverse the array
    for (int i = 1; i < n - 1; i++)
    {
 
        // If i-th element is smaller than
        // both its adjacent elements
        if (a[i + 1] > a[i]
            && a[i] < a[i - 1])
            flag = true;
    }
 
    // If flag is true
    if (flag)
        return false;
 
    // Otherwise
    else
        return true;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 3, 5, 2 };
    int N = arr.length;
 
    if (check(arr, N))
        System.out.print("YES");
    else
        System.out.print("NO");
}
}
 
// This code is contributed by code_hunt.

Python3

# Python 3 program for the above approach
 
# Function to check if it is possible
# to move all disks to a single rod
def check(a, n) :
     
    # Stores if it is possible to move
    # all disks to a single rod
    flag = 0
  
    # Traverse the array
    for i in range(1, n - 1):
  
        # If i-th element is smaller than
        # both its adjacent elements
        if (a[i + 1] > a[i]
            and a[i] < a[i - 1]) :
            flag = 1
     
    # If flag is true
    if (flag != 0) :
        return False
  
    # Otherwise
    else :
        return True
 
# Driver Code
arr = [ 1, 3, 5, 2 ]
N = len(arr)
  
if (check(arr, N) != 0):
    print("YES")
else :
    print("NO")
     
    # This code is contributed by splevel62.

C#

// C# program to implement
// the above approach
using System;
public class GFG
{
   
// Function to check if it is possible
// to move all disks to a single rod
static bool check(int[] a, int n)
{
   
    // Stores if it is possible to move
    // all disks to a single rod
    bool flag = false;
 
    // Traverse the array
    for (int i = 1; i < n - 1; i++)
    {
 
        // If i-th element is smaller than
        // both its adjacent elements
        if (a[i + 1] > a[i]
            && a[i] < a[i - 1])
            flag = true;
    }
 
    // If flag is true
    if (flag)
        return false;
 
    // Otherwise
    else
        return true;
}
  // Driver Code
  public static void Main(String[] args)
  {
    int[] arr = { 1, 3, 5, 2 };
    int N = arr.Length;
 
    if (check(arr, N))
        Console.Write("YES");
    else
        Console.Write("NO");
  }
}
 
// This code is contributed by susmitakundugoaldanga.

Javascript

 
// javascript program to implement
// the above approach
 
 
// Function to check if it is possible
// to move all disks to a single rod
function check(a , n)
{
   
    // Stores if it is possible to move
    // all disks to a single rod
    flag = false;
 
    // Traverse the array
    for (i = 1; i < n - 1; i++)
    {
 
        // If i-th element is smaller than
        // both its adjacent elements
        if (a[i + 1] > a[i]
            && a[i] < a[i - 1])
            flag = true;
    }
 
    // If flag is true
    if (flag)
        return false;
 
    // Otherwise
    else
        return true;
}
 
// Driver Code
 
 
var arr = [ 1, 3, 5, 2 ];
var N = arr.length;
 
if (check(arr, N))
    document.write("YES");
else
    document.write("NO");
 
// This code contributed by Princi Singh
 

输出：

YES

时间复杂度： O(N)
辅助空间： O(1)