通过翻转列和重新排序行来最小化将给定矩阵转换为另一个矩阵的成本

给定两个维度为N * M 的二进制矩阵 mat[][]和target[][] ，任务是使用以下操作找到将矩阵 mat[][]转换为target[][] 的最小成本：

• 翻转 mat[][] 中的特定列，使所有1变为0 ，反之亦然。此操作的成本为1 。
• 重新排序mat[][]的行。此操作的成本为 0。

如果无法将矩阵mat[][]转换为target[][] ，则打印“-1” 。

例子：

Input: mat[][] = {{0, 0}, {1, 0}, {1, 1}}, target[][] = {{0, 1}, {1, 0}, {1, 1}}
Output: 1
Explanation:
Step 1: Reorder 2^nd and 3^rd rows to modify mat[][] to {{0, 0}, {1, 1}, {1, 0}}. Cost = 0
Step 2: Flip the second column . mat[][] modifies to {{0, 1}, {1, 0}, {1, 1}}, which is equal to target[][]. Cost = 1

Input: mat[][] = {{0, 0, 0}, {1, 0, 1}, {1, 1, 0}}, target[][] = {{0, 0, 1}, {1, 0, 1}, {1, 1, 1}}
Output: -1

方法：想法是将给定矩阵的行转换为位集，然后找到最小操作成本使矩阵相等。以下是步骤：

1. 首先，使用 bitset 将 mat[][]的行转换为二进制数。
2. 完成上述步骤后，找到所有可能的行，这些行可以是目标矩阵的第一行。
3. 将 mat[][]的行转换为tar[][]所需的翻转次数是位集的按位异或值中的设置位计数。
4. 使用翻转模式计算每一行的按位异或，并检查排序后的新矩阵是否等于排序后的target[][]矩阵。
5. 如果它们相同，则存储翻转次数。
6. 在上述步骤中计算所有此类翻转计数并返回其中的最小值。

下面是上述方法的实现：

C++

// C++ program for the above approach
  
#include 
using namespace std;
  
// Custom comparator to sort vector
// of bitsets
bool static cmp(bitset<105>& p1,
                bitset<105>& p2)
{
    return p1.to_string() < p2.to_string();
}
  
// Function to convert the given
// matrix into the target matrix
int minCost(vector >& a,
            vector >& t)
{
  
    // Number of rows and columns
    int n = a.size();
    int m = a[0].size();
  
    vector > mat(n), tar(n);
  
    // Iterate over rows
    for (int i = 0; i < n; i++) {
        string s;
  
        for (int j = 0; j < m; j++) {
            s += char(a[i][j] + '0');
        }
        mat[i] = bitset<105>(s);
    }
  
    // Iterate over rows
    for (int i = 0; i < n; i++) {
        string s;
  
        for (int j = 0; j < m; j++) {
            s += char(t[i][j] + '0');
        }
        tar[i] = bitset<105>(s);
    }
  
    // Sort the matrix
    sort(tar.begin(), tar.end(), cmp);
  
    int ans = INT_MAX;
  
    // Check all possible rows as the
    // first row of target
    for (int i = 0; i < n; i++) {
  
        vector > copy(mat);
  
        // Get the flip pattern
        auto flip = copy[i] ^ tar[0];
  
        for (auto& row : copy)
            row ^= flip;
  
        sort(copy.begin(), copy.end(), cmp);
  
        // Number of flip operations
        // is the count of set bits in flip
        if (copy == tar)
            ans = min(ans, (int)flip.count());
    }
  
    // If it is not possible
    if (ans == INT_MAX)
        return -1;
  
    // Return the answer
    return ans;
}
  
// Driver Code
int main()
{
    // Given matrices
    vector > matrix{ { 0, 0 },
                                 { 1, 0 },
                                 { 1, 1 } };
  
    vector > target{ { 0, 1 },
                                 { 1, 0 },
                                 { 1, 1 } };
  
    // Function Call
    cout << minCost(matrix, target);
}

输出：

1

时间复杂度： O(N * M)
辅助空间： O(N * M)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live