Número máximo de baldosas requeridas para cubrir el piso de un tamaño dado usando baldosas de tamaño 2×1

Dado un piso de tamaño MxN y baldosas de tamaño 2×1 , la tarea es encontrar el número máximo de baldosas necesarias para cubrir el piso tanto como sea posible de tamaño MxN .
Nota: una ficha puede colocarse horizontal o verticalmente y no deben superponerse dos fichas.

Ejemplos:

Entrada: M = 2, N = 4
Salida: 4
Explicación:
se necesitan 4 baldosas para cubrir el piso.

Entrada: M = 3, N = 3
Salida: 4
Explicación:
se necesitan 4 baldosas para cubrir el piso.

Acercarse:

1. Si N es par , entonces la tarea es colocar m filas de (N/2) número de mosaicos para cubrir todo el piso.
2. De lo contrario, si N es impar , cubra M filas hasta N – 1 (par) columnas de la misma manera que se discutió en el punto anterior y coloque (M/2) número de mosaicos en la última columna. Si tanto M como N son impares , entonces queda descubierta una celda del piso.
3. Por lo tanto, el número máximo de fichas es floor((M * N) / 2) .

A continuación se muestra la implementación del enfoque anterior:

// 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 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 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# 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

<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>

6

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)