检查对角线串联的按位与是否超过二进制矩阵的中间行/列元素

给定一个维度为N * N的二进制矩阵mat[][] ，任务是检查通过连接主对角线和次要对角线元素获得的十进制数的按位与是否大于由存在的元素获得的十进制数的按位与在中间的行和列。如果发现是真的，则打印“是” 。否则，打印“否” 。

注意：仅从左到右和从上到下连接矩阵元素。如果N是偶数，则从两者中取出第一个中间行/列。

例子：

Input: M[][] = {{1, 0, 1}, {0, 0, 1}, {0, 1, 1}}
Output: No
Explanation: 
Number formed by concatenating principal diagonal elements is “101”.
Number formed by concatenating cross diagonal elements is “001”.
Number formed by concatenating elements in the middle row is “001”.
Number formed by concatenating elements in the middle column is “001”.
Therefore, the Bitwise AND of “101” and “001” is same as Bitwise AND of “001” and “001”. 

Input: M[][] = {{0, 1, 1}, {0, 0, 0}, {0, 1, 1}}
Output: Yes

朴素的方法：解决问题的最简单的方法是遍历给定的矩阵并将相应的数字附加到一个变量上，比如P，如果当前行等于当前列，则附加到一个变量，比如S，如果行是N列，一个变量，表示MR，如果行是等于N / 2，和给一个变量，表示MC，如果列是N / 2。完成上述步骤后，如果P和S 的Bitwise AND 大于MR和MC 的Bitwise AND ，则打印“Yes” 。否则，打印“否”。

下面是上述方法的实现：

C++

// C++ program for above approach
#include 
using namespace std;
 
// Function to convert obtained binary
// representation to decimal value
int convert(vector p)
{
 
    // Stores the resultant number
    int ans = 0;
 
    // Traverse string arr
    for(int i : p)
    {
        ans = (ans << 1) | i;
    }
 
    // Return the number formed
    return ans;
}
 
// Function to count the number of
// set bits in the number num
int count(int num)
{
 
    // Stores the count of set bits
    int ans = 0;
 
    // Iterate until num > 0
    while (num > 0)
    {
        ans += num & 1;
        num >>= 1;
    }
    return ans;
}
 
// Function to check if the given matrix
// satisfies the given condition or not
void checkGoodMatrix(vector > mat)
{
    vector P;
    vector S;
    vector MR;
    vector MC;
 
    // To get P, S, MR, and MC
    for(int i = 0; i < mat.size(); i++)
    {
        for(int j = 0; j < mat[0].size(); j++)
        {
            if (i == j)
                P.push_back(mat[i][j]);
 
            if (i + j == mat.size() - 1)
                S.push_back(mat[i][j]);
 
            if (i == floor((mat.size() - 1) / 2))
                MR.push_back(mat[i][j]);
 
            if (j == floor((mat.size() - 1) / 2))
                MC.push_back(mat[i][j]);
        }
    }
    reverse(S.begin(), S.end());
 
    // Stores decimal equivalents
    // of binary representations
    int P0 = convert(P);
    int S0 = convert(S);
    int MR0 = convert(MR);
    int MC0 = convert(MC);
 
    // Gett the number of set bits
    int setBitsPS = count((P0 & S0));
    int setBitsMM = count((MR0 & MC0));
 
    // Print the answer
    if (setBitsPS > setBitsMM)
        cout << "Yes";
    else
        cout << "No";
}
 
// Driver code
int main()
{
    vector> mat = { { 1, 0, 1 },
                                { 0, 0, 1 },
                                { 0, 1, 1 } };
 
    checkGoodMatrix(mat);
}
 
// This code is contributed by nirajgusain5

Java

// Java program for the above approach
import java.util.ArrayList;
import java.util.Collections;
 
// Java Program for above approach
class GFG{
     
// Function to convert obtained binary
// representation to decimal value
static int convert(ArrayList p)
{
     
    // Stores the resultant number
    int ans = 0;
     
    // Traverse string arr
    for(int i: p)
    {
        ans = (ans << 1) | i;
    }
     
    // Return the number formed
    return ans;
}
 
// Function to count the number of
// set bits in the number num
static int count(int num)
{
     
    // Stores the count of set bits
    int ans = 0;
     
    // Iterate until num > 0
    while (num > 0)
    {
        ans += num & 1;
        num >>= 1;
    }
    return ans;
}
 
// Function to check if the given matrix
// satisfies the given condition or not
static void checkGoodMatrix(int mat[][])
{
    ArrayList P = new ArrayList();
    ArrayList S = new ArrayList();
    ArrayList MR = new ArrayList();
    ArrayList MC = new ArrayList();
     
    // To get P, S, MR, and MC
    for(int i = 0; i < mat.length; i++)
    {
        for(int j = 0; j < mat[0].length; j++)
        {
            if (i == j)
                P.add(mat[i][j]);
 
            if (i + j == mat.length - 1)
                S.add(mat[i][j]);
 
            if (i == Math.floor((mat.length - 1) / 2))
                MR.add(mat[i][j]);
 
            if (j == Math.floor((mat.length - 1) / 2))
                MC.add(mat[i][j]);
        }
    }
    Collections.reverse(S);
 
    // Stores decimal equivalents
    // of binary representations
    int P0 = convert(P);
    int S0 = convert(S);
    int MR0 = convert(MR);
    int MC0 = convert(MC);
 
    // Gett the number of set bits
    int setBitsPS = count((P0 & S0));
    int setBitsMM = count((MR0 & MC0));
     
    // Print the answer
    if (setBitsPS > setBitsMM)
       System.out.print("Yes");
    else
        System.out.print("No");
}
 
// Driver code
public static void main(String[] args)
{
    int mat[][] = { { 1, 0, 1 },
                    { 0, 0, 1 },
                    { 0, 1, 1 } };
    checkGoodMatrix(mat);
}
}
 
// This code is contributed by abhinavjain194

Python3

# Python3 program for the above approach
 
# Functio to convert obtained binary
# representation to decimal value
def convert(arr):
   
      # Stores the resultant number
    ans = 0
     
    # Traverse string arr
    for i in arr:
        ans = (ans << 1) | i
         
    # Return the number formed
    return ans
 
# Function to count the number of
# set bits in the number num
def count(num):
   
    # Stores the count of set bits
    ans = 0
     
    # Iterate until num > 0
    while num:
        ans += num & 1
        num >>= 1
    return ans
 
# Function to check if the given matrix
# satisfies the given condition or not
def checkGoodMatrix(mat):
    P = []
    S = []
    MR = []
    MC = []
 
    # To get P, S, MR, and MC
    for i in range(len(mat)):
        for j in range(len(mat[0])):
 
            if i == j:
                P.append(mat[i][j])
 
            if i + j == len(mat)-1:
                S.append(mat[i][j])
 
            if i == (len(mat)-1)//2:
                MR.append(mat[i][j])
 
            if j == (len(mat)-1)//2:
                MC.append(mat[i][j])
 
    S.reverse()
 
    # Stores decimal equivalents
    # of binary representations
    P = convert(P)
    S = convert(S)
    MR = convert(MR)
    MC = convert(MC)
 
    # Gett the number of set bits
    setBitsPS = count(P & S)
    setBitsMM = count(MR & MC)
 
    # Print the answer
    if setBitsPS > setBitsMM:
        print("Yes")
    else:
        print("No")
 
# Driver Code
 
# Given Matrix
mat = [[1, 0, 1], [0, 0, 1], [0, 1, 1]]
 
checkGoodMatrix(mat)

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to convert obtained binary
// representation to decimal value
static int convert(List p)
{
     
    // Stores the resultant number
    int ans = 0;
 
    // Traverse string arr
    foreach(int i in p)
    {
        ans = (ans << 1) | i;
    }
 
    // Return the number formed
    return ans;
}
 
// Function to count the number of
// set bits in the number num
static int count(int num)
{
     
    // Stores the count of set bits
    int ans = 0;
 
    // Iterate until num > 0
    while (num > 0)
    {
        ans += num & 1;
        num >>= 1;
    }
    return ans;
}
 
// Function to check if the given matrix
// satisfies the given condition or not
static void checkGoodMatrix(int[, ] mat)
{
    List P = new List();
    List S = new List();
    List MR = new List();
    List MC = new List();
 
    // To get P, S, MR, and MC
    for(int i = 0; i < mat.GetLength(0); i++)
    {
        for(int j = 0; j < mat.GetLength(1); j++)
        {
            if (i == j)
                P.Add(mat[i, j]);
 
            if (i + j == mat.GetLength(0) - 1)
                S.Add(mat[i, j]);
 
            if (i == Math.Floor(
                (mat.GetLength(0) - 1) / 2.0))
                MR.Add(mat[i, j]);
 
            if (j == Math.Floor(
                (mat.GetLength(0) - 1) / 2.0))
                MC.Add(mat[i, j]);
        }
    }
    S.Reverse();
 
    // Stores decimal equivalents
    // of binary representations
    int P0 = convert(P);
    int S0 = convert(S);
    int MR0 = convert(MR);
    int MC0 = convert(MC);
 
    // Gett the number of set bits
    int setBitsPS = count((P0 & S0));
    int setBitsMM = count((MR0 & MC0));
 
    // Print the answer
    if (setBitsPS > setBitsMM)
        Console.Write("Yes");
    else
        Console.Write("No");
}
 
// Driver code
public static void Main(string[] args)
{
    int[,] mat = { { 1, 0, 1 },
                   { 0, 0, 1 },
                   { 0, 1, 1 } };
                    
    checkGoodMatrix(mat);
}
}
 
// This code is contributed by ukasp

输出：

No

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

高效方法：为了优化上述方法，可以通过仅遍历每个元素的对角线、中间行和中间列来优化上述方法。请按照以下步骤解决问题：

• 初始化辅助向量，比如P、S、MR和MC ，分别存储主对角线、交叉对角线、中行和中列的连通元素。
• 迭代范围[0, N – 1] ：
  • 将(i, i)处的元素附加到P ，即主对角线。
  • 将(N – 1 – i, i)处的元素附加到S ，即交叉对角线。
  • 将((N-1)/2, i)处的元素附加到MR ，即中间行。
  • 将((N-1)/2, i)处的元素附加到MC ，即中间列。
• 迭代范围[0, N – 1] ：
  • 检查是否P[i] & S[i] > MR[i] & MC[i]，然后打印“Yes”并返回。
  • 否则，检查是否p[i] & s[i] < MR[i] & MC[i] ，然后打印“No”并返回。
• 如果以上条件都不满足，则打印“No” 。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to check if the matrix
// satisfy the given condition or not
void checkGoodMatrix(
    vector > M, int N)
{
    // Stores the binary representation
    vector p, s, MR, MC;
 
    // Iterate over the range [0, N]
    for (int i = 0; i < N; i++) {
 
        // Push element of main diagonal
        p.push_back(M[i][i]);
 
        // Push element of cross diagona
        s.push_back(M[N - 1 - i][i]);
 
        // Push element of Mid row
        MR.push_back(M[(N - 1) / 2][i]);
 
        // Push element of Mid column
        MC.push_back(M[i][(N - 1) / 2]);
    }
 
    // Check if S & P > MR & MC
    for (int i = 0; i < N; i++) {
 
        if (p[i] & s[i] > MR[i] & MC[i]) {
            cout << "Yes";
            return;
        }
        else if (p[i] & s[i] < MR[i] & MC[i]) {
            cout << "No";
            return;
        }
    }
 
    cout << "No";
}
 
// Driver Code
int main()
{
    // Given matrix
    vector > M{ { 0, 1, 1 },
                            { 0, 0, 0 },
                            { 0, 1, 1 } };
 
    // Size of the matrix
    int N = M.size();
 
    checkGoodMatrix(M, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.Vector;
 
class GFG{
 
static void checkGoodMatrix(int[][] M, int N)
{
     
    // Stores the binary representation
    Vector p = new Vector();
    Vector s = new Vector();
    Vector MR = new Vector();
    Vector MC = new Vector();
 
    // Iterate over the range [0, N]
    for(int i = 0; i < N; i++)
    {
         
        // Push element of main diagonal
        p.add(M[i][i]);
 
        // Push element of cross diagona
        s.add(M[N - 1 - i][i]);
 
        // Push element of Mid row
        MR.add(M[(N - 1) / 2][i]);
 
        // Push element of Mid column
        MC.add(M[i][(N - 1) / 2]);
    }
 
    // Check if S & P > MR & MC
    for(int i = 0; i < N; i++)
    {
        int P = p.get(i);
        int S = s.get(i);
        int Mr = MR.get(i);
        int Mc = MC.get(i);
 
        if ((P & S) > (Mr & Mc))
        {
            System.out.print("Yes");
            return;
        }
        else if ((P & S) < (Mr & Mc))
        {
            System.out.print("No");
            return;
        }
    }
    System.out.print("No");
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given matrix
    int[][] M = { { 0, 1, 1 },
                  { 0, 0, 0 },
                  { 0, 1, 1 } };
 
    // Size of the matrix
    int N = M.length;
 
    checkGoodMatrix(M, N);
}
}
 
// This code is contributed by abhinavjain194

输出：

Yes

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

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