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

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)