要翻转以获得具有相等元素的 2*2 子矩阵的最小单元格

给定一个大小为M * N的矩阵，任务是找到必须翻转的最小单元格数，以便至少有一个大小为 2*2 的子矩阵，其中所有元素都相等。
例子：

Input: mat[] = {“00000”, “10111”, “00000”, “11111”} 
Output: 1 
One of the possible submatrix could be {{0, 0}, {1, 0}} 
where only a single element has to be flipped.
Input: mat[] = {“0101”, “0101”, “0101”} 
Output: 3 
 

方法：对于每个大小为 2*2 的子矩阵，计算其中 0 的数量和 1 的数量，这两者中的最小值将是获得具有所有相等元素的矩阵所需的翻转次数。所有子矩阵的此值的最小值是所需的答案。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the minimum flips
// required such that the submatrix from
// mat[i][j] to mat[i + 1][j + 1]
// contains all equal elements
int minFlipsSub(string mat[], int i, int j)
{
    int cnt0 = 0, cnt1 = 0;
 
    if (mat[i][j] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i][j + 1] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1][j] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1][j + 1] == '1')
        cnt1++;
    else
        cnt0++;
 
    return min(cnt0, cnt1);
}
 
// Function to return the minimum number
// of slips required such that the matrix
// contains at least a single submatrix
// of size 2*2 with all equal elements
int minFlips(string mat[], int r, int c)
{
 
    // To store the result
    int res = INT_MAX;
 
    // For every submatrix of size 2*2
    for (int i = 0; i < r - 1; i++) {
        for (int j = 0; j < c - 1; j++) {
 
            // Update the count of flips required
            // for the current submatrix
            res = min(res, minFlipsSub(mat, i, j));
        }
    }
 
    return res;
}
 
// Driver code
int main()
{
    string mat[] = { "0101", "0101", "0101" };
    int r = sizeof(mat) / sizeof(string);
    int c = mat[0].length();
 
    cout << minFlips(mat, r, c);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
 
// Function to return the minimum flips
// required such that the submatrix from
// mat[i][j] to mat[i + 1][j + 1]
// contains all equal elements
static int minFlipsSub(String mat[], int i, int j)
{
    int cnt0 = 0, cnt1 = 0;
 
    if (mat[i].charAt(j) == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i].charAt(j+1) == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1].charAt(j) == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1].charAt(j+1) == '1')
        cnt1++;
    else
        cnt0++;
 
    return Math.min(cnt0, cnt1);
}
 
// Function to return the minimum number
// of slips required such that the matrix
// contains at least a single submatrix
// of size 2*2 with all equal elements
static int minFlips(String mat[], int r, int c)
{
    // To store the result
    int res = Integer.MAX_VALUE;
 
    // For every submatrix of size 2*2
    for (int i = 0; i < r - 1; i++)
    {
        for (int j = 0; j < c - 1; j++)
        {
            // Update the count of flips required
            // for the current submatrix
            res = Math.min(res, minFlipsSub(mat, i, j));
        }
    }
    return res;
}
 
// Driver code
public static void main(String[] args)
{
    String mat[] = { "0101", "0101", "0101" };
    int r = mat.length;
    int c = mat[0].length();
 
    System.out.print(minFlips(mat, r, c));
}
}
 
// This code is contributed by 29AjayKumar

Python 3

# Python 3 implementation of the approach
import sys
 
# Function to return the minimum flips
# required such that the submatrix from
# mat[i][j] to mat[i + 1][j + 1]
# contains all equal elements
def minFlipsSub(mat, i, j):
    cnt0 = 0
    cnt1 = 0
 
    if (mat[i][j] == '1'):
        cnt1 += 1
    else:
        cnt0 += 1
 
    if (mat[i][j + 1] == '1'):
        cnt1 += 1
    else:
        cnt0 += 1
 
    if (mat[i + 1][j] == '1'):
        cnt1 += 1
    else:
        cnt0 += 1
 
    if (mat[i + 1][j + 1] == '1'):
        cnt1 += 1
    else:
        cnt0 += 1
 
    return min(cnt0, cnt1)
 
# Function to return the minimum number
# of slips required such that the matrix
# contains at least a single submatrix
# of size 2*2 with all equal elements
def minFlips(mat, r, c):
     
    # To store the result
    res = sys.maxsize
 
    # For every submatrix of size 2*2
    for i in range(r - 1):
        for j in range(c - 1):
             
            # Update the count of flips required
            # for the current submatrix
            res = min(res, minFlipsSub(mat, i, j))
 
    return res
 
# Driver code
if __name__ == '__main__':
    mat = ["0101", "0101", "0101"]
    r = len(mat)
    c = len(mat[0])
 
    print(minFlips(mat, r, c))
     
# This code is contributed by Surendra_Gangwar

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the minimum flips
// required such that the submatrix from
// mat[i,j] to mat[i + 1,j + 1]
// contains all equal elements
static int minFlipsSub(String []mat,
                       int i, int j)
{
    int cnt0 = 0, cnt1 = 0;
 
    if (mat[i][j] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i][j + 1] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1][j] == '1')
        cnt1++;
    else
        cnt0++;
 
    if (mat[i + 1][j + 1] == '1')
        cnt1++;
    else
        cnt0++;
 
    return Math.Min(cnt0, cnt1);
}
 
// Function to return the minimum number
// of slips required such that the matrix
// contains at least a single submatrix
// of size 2*2 with all equal elements
static int minFlips(String []mat,
                    int r, int c)
{
    // To store the result
    int res = int.MaxValue;
 
    // For every submatrix of size 2*2
    for (int i = 0; i < r - 1; i++)
    {
        for (int j = 0; j < c - 1; j++)
        {
            // Update the count of flips required
            // for the current submatrix
            res = Math.Min(res, minFlipsSub(mat, i, j));
        }
    }
    return res;
}
 
// Driver code
public static void Main(String[] args)
{
    String []mat = { "0101", "0101", "0101" };
    int r = mat.Length;
    int c = mat.GetLength(0);
 
    Console.Write(minFlips(mat, r, c));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// javascript implementation of the approach   
// Function to return the minimum flips
    // required such that the submatrix from
    // mat[i][j] to mat[i + 1][j + 1]
    // contains all equal elements
    function minFlipsSub( mat , i , j)
    {
        var cnt0 = 0, cnt1 = 0;
 
        if (mat[i].charAt(j) == '1')
            cnt1++;
        else
            cnt0++;
 
        if (mat[i].charAt(j + 1) == '1')
            cnt1++;
        else
            cnt0++;
 
        if (mat[i + 1].charAt(j) == '1')
            cnt1++;
        else
            cnt0++;
 
        if (mat[i + 1].charAt(j + 1) == '1')
            cnt1++;
        else
            cnt0++;
 
        return Math.min(cnt0, cnt1);
    }
 
    // Function to return the minimum number
    // of slips required such that the matrix
    // contains at least a single submatrix
    // of size 2*2 with all equal elements
    function minFlips(mat , r , c)
    {
     
        // To store the result
        var res = Number.MAX_VALUE;
 
        // For every submatrix of size 2*2
        for (i = 0; i < r - 1; i++)
        {
            for (j = 0; j < c - 1; j++)
            {
             
                // Update the count of flips required
                // for the current submatrix
                res = Math.min(res, minFlipsSub(mat, i, j));
            }
        }
        return res;
    }
 
    // Driver code
        var mat = [ "0101", "0101", "0101" ];
        var r = mat.length;
        var c = mat[0].length;
 
        document.write(minFlips(mat, r, c));
         
// This code is contributed by Rajput-Ji

输出：

2

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。