Maximum number of tiles required to cover the floor of given size using 2x1 size tiles

Given a floor of size MxN size and tiles of size 2x1, the task is to find the maximum number of tiles required to cover the floor as much as possible of size MxN size.
Note: A tile can either be placed horizontally or vertically and no two tiles should overlap.

Examples:

Input: M = 2, N = 4
Output: 4
Explanation:
4 tiles are needed to cover the floor.

Input: M = 3, N = 3
Output: 4
Explanation:
4 tiles are needed to cover the floor.

Approach:

1. If N is even, then the task is to place m rows of (N/2) number of tiles to cover the whole floor.
2. Else if N is odd, then cover M rows till N - 1 (even) columns in the same way as discussed in the above point and put (M/2) number of tiles in the last column. If both M and N are odd, then one cell of the floor remains uncovered.
3. Therefore, the maximum number of tiles is floor((M * N) / 2).

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum number
// of tiles required to cover the floor
// of size m x n using 2 x 1 size tiles
void maximumTiles(int n, int m)
{
    // Print the answer
    cout << (m * n) / 2 << endl;
}

// Driver Code
int main()
{
    // Given M and N
    int M = 3;
    int N = 4;

    // Function Call
    maximumTiles(N, M);
    return 0;
}

Java

// Java program for the above approach 
import java.util.*;

class GFG{

// Function to find the maximum number
// of tiles required to cover the floor
// of size m x n using 2 x 1 size tiles
static void maximumTiles(int n, int m)
{
    
    // Print the answer
    System.out.println((m * n) / 2);
}

// Driver code
public static void main (String[] args)
{

    // Given M and N
    int M = 3;
    int N = 4;
    
    // Function call
    maximumTiles(N, M);
}
}

// This code is contributed by offbeat

Python3

# Python3 program for the above approach 

# Function to find the maximum number
# of tiles required to cover the floor
# of size m x n using 2 x 1 size tiles
def maximumTiles(n, m):

    # Print the answer
    print(int((m * n) / 2));

# Driver code
if __name__ == '__main__':

    # Given M and N
    M = 3;
    N = 4;

    # Function call
    maximumTiles(N, M);

# This code is contributed by sapnasingh4991 

C#

// C# program for the above approach 
using System;

class GFG{

// Function to find the maximum number
// of tiles required to cover the floor
// of size m x n using 2 x 1 size tiles
static void maximumTiles(int n, int m)
{
    
    // Print the answer
    Console.WriteLine((m * n) / 2);
}

// Driver code
public static void Main(String[] args)
{

    // Given M and N
    int M = 3;
    int N = 4;
    
    // Function call
    maximumTiles(N, M);
}
}

// This code is contributed by amal kumar choubey

JavaScript

<script>

// JavaScript program for the above approach

// Function to find the maximum number
// of tiles required to cover the floor
// of size m x n using 2 x 1 size tiles
function maximumTiles(n, m)
{
     
    // Print the answer
    document.write((m * n) / 2);
}
    
// Driver Code
    
     // Given M and N
    let M = 3;
    let N = 4;
     
    // Function call
    maximumTiles(N, M);
             
</script>

Output:

6

Time Complexity: O(1)
Auxiliary Space: O(1)

Create Quiz