# Minimize cost to cover floor using tiles of dimensions 1*1 and 1*2

• Last Updated : 05 Jul, 2021

Given a 2D array arr[][] of size N*M consisting of ‘.’ and ‘*’ characters representing a floor and two positive integers A and B representing the cost of a 1*1 and 1*2 tile respectively, the task is to fill all the characters having ‘.’ on the floor with the tiles of dimensions 1*1 or 1*2 such that the cost of filling the floor is minimized and rotation of the tiles is not allowed.

Examples:

Input: A = 2, B = 10, arr[][] = {{‘.’, ‘.’, ‘*’},  {‘.’, ‘*’, ‘*’}}
Output: 6
Explanation:
Cover arr with 1*1 tile, arr with 1*1 tile and arr with 1*1 tile.
Therefore, the minimum cost is 2 + 2 +2 = 6.

Input: A = 2, B = 6, arr[][] = {{‘.’, ‘.’, ‘.’}, {‘*’, ‘*’, ‘.’}, {‘.’, ‘.’, ‘*’}}
Output: 12

Approach: The given problem can be solved by using the Greedy Approach. The idea is to traverse the given 2D array row-wise, and if two consecutive ‘.’ is encountered, then choose the tile with a minimum cost of placing two 1 * 1 tiles or one 1 * 2 tile. Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0 to store the minimum total cost.
• Traverse the given 2D array arr[][] row-wise using i for row-index and j for column index and perform the following steps:
• If the value of arr[i][j] is equal to ‘*’, then continue the iteration.
• Otherwise, check for the following conditions:
• If the value of j is m(M – 1), then add A to the variable ans.
• Otherwise, if the value of (arr[i][j + 1]) is ‘.’, then add the minimum of the values 2*A and B to the variable ans.
• In all other cases, add the value of A to the variable ans.
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum cost``// of flooring with the given tiles``void` `minCost(vector > arr,``             ``int` `A, ``int` `B)``{``    ``// Store the size of the 2d array``    ``int` `n = arr.size();``    ``int` `m = arr.size();` `    ``// Stores the minimum cost of``    ``// flooring``    ``int` `ans = 0;` `    ``// Traverse the 2d array row-wise``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = 0; j < m; j++) {` `            ``// If the current character``            ``// is '*', then skip it``            ``if` `(arr[i][j] == ``'*'``)``                ``continue``;` `            ``// Choose the 1*1 tile if``            ``// j is m-1``            ``if` `(j == m - 1)``                ``ans += A;` `            ``// If consecutive '.' are``            ``// present, the greedily``            ``// choose tile with the``            ``// minimum cost``            ``else` `{``                ``if` `(arr[i][j + 1] == ``'.'``) {``                    ``ans += min(2 * A, B);``                    ``j++;``                ``}` `                ``// Otherwise choose``                ``// the 1*1 tile``                ``else``                    ``ans += A;``            ``}``        ``}``    ``}` `    ``// Print the minimum cost``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``vector > arr = { { ``'.'``, ``'.'``, ``'*'` `},``                                  ``{ ``'.'``, ``'*'``, ``'*'` `} };``    ``int` `A = 2, B = 10;``    ``minCost(arr, A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `MyClass``{``    ` `// Function to find the minimum cost``// of flooring with the given tiles``static` `void` `minCost(``char` `arr[][], ``int` `A, ``int` `B)``{``  ` `    ``// Store the size of the 2d array``    ``int` `n = arr.length;``    ``int` `m = arr[``0``].length;` `    ``// Stores the minimum cost of``    ``// flooring``    ``int` `ans = ``0``;` `    ``// Traverse the 2d array row-wise``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``for` `(``int` `j = ``0``; j < m; j++) {` `            ``// If the current character``            ``// is '*', then skip it``            ``if` `(arr[i][j] == ``'*'``)``                ``continue``;` `            ``// Choose the 1*1 tile if``            ``// j is m-1``            ``if` `(j == m - ``1``)``                ``ans += A;` `            ``// If consecutive '.' are``            ``// present, the greedily``            ``// choose tile with the``            ``// minimum cost``            ``else` `{``                ``if` `(arr[i][j + ``1``] == ``'.'``) {``                    ``ans += Math.min(``2` `* A, B);``                    ``j++;``                ``}` `                ``// Otherwise choose``                ``// the 1*1 tile``                ``else``                    ``ans += A;``            ``}``        ``}``    ``}` `    ``// Print the minimum cost``    ``System.out.println(ans);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``char` `[][]arr = { { ``'.'``, ``'.'``, ``'*'` `},``                                  ``{ ``'.'``, ``'*'``, ``'*'` `} };``    ``int` `A = ``2``, B = ``10``;``    ``minCost(arr, A, B);``}``}` `// This code is contributed by SoumikMondal`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum cost``# of flooring with the given tiles``def` `minCost(arr, A, B):``    ` `    ``# Store the size of the 2d array``    ``n ``=` `len``(arr)``    ``m ``=` `len``(arr[``0``])` `    ``# Stores the minimum cost of``    ``# flooring``    ``ans ``=` `0` `    ``# Traverse the 2d array row-wise``    ``for` `i ``in` `range``(n):``        ``j ``=` `0``        ` `        ``while` `j < m:``            ` `            ``# If the current character``            ``# is '*', then skip it``            ``if` `(arr[i][j] ``=``=` `'*'``):``                ``j ``+``=` `1``                ``continue``            ` `            ``# Choose the 1*1 tile if``            ``# j is m-1``            ``if` `(j ``=``=` `m ``-` `1``):``                ``ans ``+``=` `A``                ` `            ``# If consecutive '.' are``            ``# present, the greedily``            ``# choose tile with the``            ``# minimum cost``            ``else``:``                ``if` `(arr[i][j ``+` `1``] ``=``=` `'.'``):``                    ``ans ``+``=` `min``(``2` `*` `A, B)``                    ``j ``+``=` `1``                    ` `                ``# Otherwise choose``                ``# the 1*1 tile``                ``else``:``                    ``ans ``+``=` `A``                    ` `            ``j ``+``=` `1` `    ``# Print the minimum cost``    ``print` `(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ [ ``'.'``, ``'.'``, ``'*'` `],``            ``[ ``'.'``, ``'*'``, ``'*'` `] ]``    ``A, B ``=` `2``, ``10``    ` `    ``minCost(arr, A, B)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG{``    ` `    ``// Function to find the minimum cost``// of flooring with the given tiles``static` `void` `minCost(``char``[,] arr, ``int` `A, ``int` `B)``{``   ` `    ``// Store the size of the 2d array``    ``int` `n = arr.GetLength(0);``    ``int` `m = arr.GetLength(1);`` ` `    ``// Stores the minimum cost of``    ``// flooring``    ``int` `ans = 0;`` ` `    ``// Traverse the 2d array row-wise``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = 0; j < m; j++) {`` ` `            ``// If the current character``            ``// is '*', then skip it``            ``if` `(arr[i,j] == ``'*'``)``                ``continue``;`` ` `            ``// Choose the 1*1 tile if``            ``// j is m-1``            ``if` `(j == m - 1)``                ``ans += A;`` ` `            ``// If consecutive '.' are``            ``// present, the greedily``            ``// choose tile with the``            ``// minimum cost``            ``else` `{``                ``if` `(arr[i,j + 1] == ``'.'``) {``                    ``ans += Math.Min(2 * A, B);``                    ``j++;``                ``}`` ` `                ``// Otherwise choose``                ``// the 1*1 tile``                ``else``                    ``ans += A;``            ``}``        ``}``    ``}`` ` `    ``// Print the minimum cost``    ``Console.WriteLine(ans);``}`` ` `// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ` `        ``char``[,] arr = { { ``'.'``, ``'.'``, ``'*'` `},``                                  ``{ ``'.'``, ``'*'``, ``'*'` `} };``    ``int` `A = 2, B = 10;``    ``minCost(arr, A, B);``        ` `    ``}``}` `// This code is contributed by patel2127.`

## Javascript

 ``

Output:

`6`

Time Complexity: O(N * M)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up