Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
  • 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[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.
  • 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;
}

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




<script>
// JavaScript program for the above approach
 
        // Function to find the minimum cost
        // of flooring with the given tiles
        function minCost(arr, A, B)
        {
         
            // Store the size of the 2d array
            let n = arr.length;
            let m = arr[0].length;
 
            // Stores the minimum cost of
            // flooring
            let ans = 0;
 
            // Traverse the 2d array row-wise
            for (let i = 0; i < n; i++) {
                for (let 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
            document.write(ans);
        }
 
        // Driver Code
        var arr = [['.', '.', '*'],
        ['.', '*', '*']];
        let A = 2, B = 10;
        minCost(arr, A, B);
 
  // This code is contributed by Potta Lokesh
    </script>

Output: 

6

 

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!