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:6Explanation:

Cover arr[0][0] with 1*1 tile, arr[0][1] with 1*1 tile and arr[1][0] 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**.

- If the value of

- If the value of
- 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 <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum cost` `// of flooring with the given tiles` `void` `minCost(vector<vector<` `char` `> > arr,` ` ` `int` `A, ` `int` `B)` `{` ` ` `// Store the size of the 2d array` ` ` `int` `n = arr.size();` ` ` `int` `m = arr[0].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<vector<` `char` `> > arr = { { ` `'.'` `, ` `'.'` `, ` `'*'` `},` ` ` `{ ` `'.'` `, ` `'*'` `, ` `'*'` `} };` ` ` `int` `A = 2, B = 10;` ` ` `minCost(arr, A, B);` ` ` `return` `0;` `}` |

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

**Output:**

6

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**