Cuente las fichas de dimensiones 2 * 1 que se pueden colocar en un tablero rectangular M * N que satisfaga las condiciones dadas

Dados dos enteros M y N , la tarea es encontrar el número mínimo de mosaicos de tamaño 2 * 1 que se pueden colocar en una cuadrícula M * N tal que se cumplan las siguientes condiciones:

1. Cada ficha debe cubrir por completo 2 casillas del tablero.
2. Ningún par de fichas puede superponerse.
3. Cada ficha debe colocarse completamente dentro del tablero. Está permitido tocar los bordes del tablero.

Si no es posible cubrir todo el tablero, imprima -1

Entrada: N = 2, M = 4
Salida: 4
Explicación: 4 mosaicos de dimensión 2 * 1. Coloque cada mosaico en una columna.

Entrada: N = 3, M = 3
Salida: -1

Enfoque: siga los pasos a continuación para resolver el problema

1. Si N es par, se pueden colocar (N/2) * M fichas para cubrir todo el tablero.
2. Si N es impar, mosaicos de 2 * 1 mosaicos, ya que la longitud es impar, lo que no se puede expresar como un múltiplo de 2

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

// C++ Program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count tiles of dimensions
// 2 x 1 that can be placed in a grid of
// dimensions M * N as per given conditions
int numberOfTiles(int N, int M)
{
    if (N % 2 == 1) {
        return -1;
    }
 
    // Number of tiles required
    return (N * 1LL * M) / 2;
}
 
// Driver Code
int main()
{
    int N = 2, M = 4;
    cout << numberOfTiles(N, M);
 
    return 0;
}

// Java Program to implement
// the above approach
 
import java.io.*;
 
class GFG {
 
    // Function to count tiles of dimensions
    // 2 x 1 that can be placed in a grid of
    // dimensions M * N as per given conditions
    static int numberOfTiles(int n, int m)
    {
        if (n % 2 == 1) {
            return -1;
        }
        // Number of tiles required
        return (m * n) / 2;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 2, m = 4;
        System.out.println(
            numberOfTiles(n, m));
    }
}

# Python Program to implement
# the above approach
 
# Function to count tiles of dimensions
# 2 x 1 that can be placed in a grid of
# dimensions M * N as per given conditions
def numberOfTiles(N, M):
    if (N % 2 == 1):
        return -1
     
    # Number of tiles required
    return (N * M) // 2
 
# Driver Code
N = 2
M = 4
print(numberOfTiles(N, M))
 
# This code is contributed by shubhamsingh10

// C# Program to implement
// the above approach
 
using System;
 
public class GFG {
 
    // Function to tiles of size 2 x 1
    // find the number of tiles that can
    // be placed as per the given conditions
    static int numberOfTiles(int n, int m)
    {
        if (n % 2 == 1) {
            return -1;
        }
        // Number of tiles required
        return (m * n) / 2;
    }
 
    // Driver Code
    static public void Main()
    {
        int n = 2, m = 4;
        Console.WriteLine(
            numberOfTiles(n, m));
    }
}

<script>
 
// Javascript Program to implement
// the above approach
 
// Function to count tiles of dimensions
// 2 x 1 that can be placed in a grid of
// dimensions M * N as per given conditions
function numberOfTiles(n, m)
{
    if (n % 2 == 1)
    {
        return -1;
    }
     
    // Number of tiles required
    return (m * n) / 2;
}
 
// Driver Code
var n = 2, m = 4;
 
document.write(numberOfTiles(n, m));
 
// This code is contributed by kirti
 
</script>

4

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