Check if it is possible to rearrange rectangles in a non-ascending order of breadths

Given n number of rectangles with it’s L-length and B-Breadth. We can turn any rectangle by 90 degrees. In other words, after turning them, the breadth will become length and length will be breadth.
The task is to check if there is a way to make the rectangles go in order of non-ascending breadth. That is, a breadth of every rectangle has to be not greater than the breadth of the previous rectangle.
Note: You can not change the order of the rectangles.

Examples:

Input: 3
l = 3, b = 4
l1 = 4, b1 = 6
l2 = 3, b2 = 5
Output: YES
The given breadths are [ 4, 6, 5 ] we can rotate the second and the third rectangle so that the breadths will satisfy the above condition [ 4, 4, 3 ] ( 3 is not greater than 4 and 4 is not greater than 4 ) which is why we print YES.



Input: 3
1 60
70 55
56 80
Output: NO
The breadths are [ 60, 55, 80 ] as 55 55 or 56 > 55. So it’s not possible to arrange the breadths in non-ascending order, which is why we’ll print NO.

Approach: Below is the step by step algorithm to solve this problem:

  1. Initialize n rectangle with their lengths and breadths.
  2. Iterate over the rectangle from left to right.
  3. Turn each rectangle in such a way that it’s breadth is as big as possible but not greater than the previous rectangle.
  4. If on some iteration there is no such way to place the rectangle, the answer is “NO”

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to check if it possible to form
// rectangles with heights as non-ascending
int rotateRec(int n, int L[], int B[])
{
  
    // set maximum
    int m = INT_MAX;
  
    for (int i = 0; i < n; i++) {
        // replace the maximum with previous maximum
        if (max(L[i], B[i]) <= m)
            m = max(L[i], B[i]);
  
        // replace the minimum with previous minimum
        else if (min(L[i], B[i]) <= m)
            m = min(L[i], B[i]);
  
        // print NO if the above 
        // two conditions fail at least once
        else {
            return 0;
        }
    }
    return 1;
}
  
// Driver code
int main()
{
    // initialize the number of rectangles
    int n = 3;
  
    // initialize n rectangles with length and breadth
    int L[] = { 5, 5, 6 };
    int B[] = { 6, 7, 8 };
    rotateRec(n, L, B) == 1 ? cout << "YES" 
                            : cout << "NO";
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above approach
import java.io.*;
  
class GFG {
     
// Function to check if it possible to form
// rectangles with heights as non-ascending
 static int rotateRec(int n, int L[], int B[])
{
  
    // set maximum
    int m = Integer.MAX_VALUE;
  
    for (int i = 0; i < n; i++) {
        // replace the maximum with previous maximum
        if (Math.max(L[i], B[i]) <= m)
            m = Math.max(L[i], B[i]);
  
        // replace the minimum with previous minimum
        else if (Math.min(L[i], B[i]) <= m)
            m = Math.min(L[i], B[i]);
  
        // print NO if the above 
        // two conditions fail at least once
        else {
            return 0;
        }
    }
    return 1;
}
  
// Driver code
  
    public static void main (String[] args) {
    // initialize the number of rectangles
    int n = 3;
  
    // initialize n rectangles with length and breadth
    int L[] = { 5, 5, 6 };
    int B[] = { 6, 7, 8 };
    if(rotateRec(n, L, B) == 1)
     System.out.println( "YES");
     else
     System.out.println( "NO");
    }
}
 // This Code is contributed by inder_verma..

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of above approach
import sys;
  
# Function to check if it possible 
# to form rectangles with heights 
# as non-ascending
def rotateRec(n, L, B):
  
    # set maximum
    m = sys.maxsize;
  
    for i in range(n):
  
        # replace the maximum with
        # previous maximum
        if (max(L[i], B[i]) <= m):
            m = max(L[i], B[i]);
  
        # replace the minimum 
        # with previous minimum
        elif (min(L[i], B[i]) <= m):
            m = min(L[i], B[i]);
  
        # print NO if the above two 
        # conditions fail at least once
        else:
            return 0;
      
    return 1;
  
# Driver code
  
# initialize the number
# of rectangles
n = 3;
  
# initialize n rectangles
# with length and breadth
L = [5, 5, 6];
B = [ 6, 7, 8 ];
if(rotateRec(n, L, B) == 1):
    print("YES");
else:
    print("NO");
  
# This code is contributed by mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of above approach 
using System;
  
class GFG 
      
// Function to check if it possible 
// to form rectangles with heights 
// as non-ascending 
static int rotateRec(int n, int []L, 
                            int []B) 
  
    // set maximum 
    int m = int.MaxValue ;
  
    for (int i = 0; i < n; i++) 
    
        // replace the maximum with 
        // previous maximum 
        if (Math.Max(L[i], B[i]) <= m) 
            m = Math.Max(L[i], B[i]); 
  
        // replace the minimum with
        // previous minimum 
        else if (Math.Min(L[i], B[i]) <= m) 
            m = Math.Min(L[i], B[i]); 
  
        // print NO if the above 
        // two conditions fail 
        // at least once 
        else 
        
            return 0; 
        
    
    return 1; 
  
// Driver code 
public static void Main () 
    // initialize the number
    // of rectangles 
    int n = 3; 
      
    // initialize n rectangles with
    // length and breadth 
    int []L = { 5, 5, 6 }; 
    int []B = { 6, 7, 8 }; 
    if(rotateRec(n, L, B) == 1) 
    Console.WriteLine("YES"); 
    else
    Console.WriteLine("NO"); 
}
  
// This code is contributed 
// by inder_verma

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of above approach
  
// Function to check if it possible 
// to form rectangles with heights 
// as non-ascending
function rotateRec($n, $L, $B)
{
  
    // set maximum
    $m = PHP_INT_MAX;
  
    for ($i = 0; $i < $n; $i++)
    {
        // replace the maximum with
        // previous maximum
        if (max($L[$i], $B[$i]) <= $m)
            $m = max($L[$i], $B[$i]);
  
        // replace the minimum 
        // with previous minimum
        else if (min($L[$i], $B[$i]) <= $m)
            $m = min($L[$i], $B[$i]);
  
        // print NO if the above two 
        // conditions fail at least once
        else 
        {
            return 0;
        }
    }
    return 1;
}
  
// Driver code
  
// initialize the number
// of rectangles
$n = 3;
  
// initialize n rectangles
// with length and breadth
$L = array(5, 5, 6 );
$B = array( 6, 7, 8 );
if(rotateRec($n, $L, $B) == 1)
    echo "YES";
else
    echo "NO";
  
// This code is contributed 
// by Shashank
?>

chevron_right


Output:

NO


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.