从给定矩阵的左上角到右下角单元格的路径的最大异或

给定维度为N * M的矩阵mat[][] ，任务是打印从左上角单元格(0, 0)到右下角单元格(给定矩阵的N – 1, M – 1) 。只有来自任何单元格(i, j) 的可能移动是(i + 1, j)和(i, j + 1) 。
注意：路径的按位异或值定义为该路径上所有可能元素的按位异或。

例子：

Input: mat[][] = {{3, 2, 1}, {6, 5, 4}, {7, 8, 9}} 
Output: 13 
Explanation: 
Possible paths from (0, 0) to (N – 1, M – 1) and their bitwise XOR values are: 
(0, 0) -> (0, 1) -> (0, 2) -> (1, 2) -> (2, 2) having XOR value 13. 
(0, 0) -> (0, 1) -> (1, 1) -> (1, 2) -> (2, 2) having XOR value 9. 
(0, 0) -> (1, 0) -> (1, 1) -> (1, 2) -> (2, 2) having XOR value 13. 
(0, 0) -> (0, 1) -> (1, 1) -> (2, 1) -> (2, 2) having XOR value 5. 
(0, 0) -> (1, 0) -> (1, 1) -> (2, 1) -> (2, 2) having XOR value 1. 
(0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (2, 2) having XOR value 3 
Therefore, the maximum bitwise XOR value for all possible paths is 13. 
 

Input: mat[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} 
Output: 15 

方法：想法是使用递归生成从给定矩阵的左上角单元格(0, 0)到右下角单元格(N – 1, M – 1)的所有可能路径，并打印所有的最大 XOR 值可能的路径。以下是递推关系及其基本情况：

Recurrence relation: 
printMaxXOR(i, j, xorValue) = max(printMaxXOR(i – 1, j, xorValue ^ mat[i][j]), printMaxXOR(i, j – 1, xorValue ^ mat[i][j]))

Base Case: 
if i = 0 and j = 0: return mat[i][j] ^ xorValue 
if i = 0: return printMaxXOR(i, j – 1, mat[i][j] ^ xorValue) 
if j = 0: return printMaxXOR(i – 1, j, mat[i][j] ^ xorValue) 

请按照以下步骤解决问题：

• 初始化一个变量，比如xorValue来存储从左上角单元格(0, 0)到右下角单元格(N – 1, M – 1)的路径上所有可能元素的按位异或。
• 使用上面的递推关系找到从左上角单元格(0, 0)到右下角单元格(N – 1, M – 1)的所有可能路径的最大 XOR 值。
• 最后，打印从左上角单元格(0, 0)到右下角单元格(N – 1, M – 1)的所有可能路径的最大 XOR 值。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to print maximum XOR
// value of all possible path
// from (0, 0) to (N - 1, M - 1)
int printMaxXOR(vector >& mat,
                int i, int j,
                int xorValue)
{
    // Base case
    if (i == 0 && j == 0) {
        return mat[i][j] ^ xorValue;
    }
 
    // Base case
    if (i == 0) {
 
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i, j - 1)
        return printMaxXOR(mat, i, j - 1,
                           mat[i][j] ^ xorValue);
    }
 
    if (j == 0) {
 
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i - 1, j)
        return printMaxXOR(mat, i - 1, j,
                           mat[i][j] ^ xorValue);
    }
 
    // Stores maximum XOR value
    // by selecting path from (i, j)
    // to (i - 1, j)
    int X
        = printMaxXOR(mat, i - 1,
                      j, mat[i][j] ^ xorValue);
 
    // Stores maximum XOR value
    // by selecting path from (i, j)
    // to (i, j - 1)
    int Y
        = printMaxXOR(mat, i, j - 1,
                      mat[i][j] ^ xorValue);
 
    return max(X, Y);
}
 
// Driver Code
int main()
{
    vector > mat
        = { { 3, 2, 1 },
           { 6, 5, 4 },
           { 7, 8, 9 } };
    int N = mat.size();
    int M = mat[0].size();
 
    // Stores bitwise XOR of
    // all elements on each possible path
    int xorValue = 0;
    cout << printMaxXOR(mat, N - 1,
                        M - 1, xorValue);
}

Java

import java.io.*;
import java.util.*;
class GFG {
    public static int printMaxXOR(int[][] mat,
                                  int i, int j,
                                  int xorValue)
    {
        // Base case
        if (i == 0 && j == 0)
        {
            return mat[i][j] ^ xorValue;
        }
 
        // Base case
        if (i == 0) {
 
            // Stores maximum XOR value
            // by selecting path from (i, j)
            // to (i, j - 1)
            return printMaxXOR(mat, i,
                               j - 1,
                               mat[i][j] ^ xorValue);
        }
 
        if (j == 0) {
 
            // Stores maximum XOR value
            // by selecting path from (i, j)
            // to (i - 1, j)
            return printMaxXOR(mat,
                               i - 1, j,
                               mat[i][j] ^ xorValue);
        }
 
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i - 1, j)
        int X = printMaxXOR(mat,
                            i - 1, j,
                            mat[i][j] ^ xorValue);
 
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i, j - 1)
        int Y = printMaxXOR(mat,
                            i, j - 1,
                            mat[i][j] ^ xorValue);
 
        return Math.max(X, Y);
    }
   
    // Driver Code
    public static void main(String[] args)
    {
 
        int[][] mat
            = { { 3, 2, 1 },
               { 6, 5, 4 },
               { 7, 8, 9 } };
        int N = mat.length;
        int M = mat[0].length;
 
        // Stores bitwise XOR of
        // all elements on each possible path
        int xorValue = 0;
        System.out.println(
            printMaxXOR(mat, N - 1, M - 1, xorValue));
    }
    // This code is contributed by hemanth gadarla
}

Python3

# Python 3 program to implement
# the above approach
 
# Function to print maximum XOR
# value of all possible path
# from (0, 0) to (N - 1, M - 1)
def printMaxXOR(mat, i, j,
                xorValue):
 
    # Base case
    if (i == 0 and j == 0):
        return mat[i][j] ^ xorValue
 
    # Base case
    if (i == 0):
 
        # Stores maximum XOR value
        # by selecting path from (i, j)
        # to (i, j - 1)
        return printMaxXOR(mat, i, j - 1,
                           mat[i][j] ^
                           xorValue)     
    if (j == 0):
 
        # Stores maximum XOR value
        # by selecting path from (i, j)
        # to (i - 1, j)
        return printMaxXOR(mat, i - 1, j,
                           mat[i][j] ^
                           xorValue)
 
    # Stores maximum XOR value
    # by selecting path from (i, j)
    # to (i - 1, j)
    X = printMaxXOR(mat, i - 1,
                    j, mat[i][j] ^
                    xorValue)
 
    # Stores maximum XOR value
    # by selecting path from (i, j)
    # to (i, j - 1)
    Y = printMaxXOR(mat, i, j - 1,
                    mat[i][j] ^
                    xorValue)
 
    return max(X, Y)
 
  # Driver Code
if __name__ == "__main__":
 
    mat = [[3, 2, 1],
           [6, 5, 4],
           [7, 8, 9]]
    N = len(mat)
    M = len(mat[0])
 
    # Stores bitwise XOR of
    # all elements on each
    # possible path
    xorValue = 0
    print(printMaxXOR(mat, N - 1,
                      M - 1,
                      xorValue))
 
# This code is contributed by Chitranayal

C#

// C# program to implement the
// above approach
using System;
class GFG{
     
public static int printMaxXOR(int[,] mat,
                              int i, int j,
                              int xorValue)
{
  // Base case
  if (i == 0 && j == 0)
  {
    return mat[i,j] ^
           xorValue;
  }
 
  // Base case
  if (i == 0)
  {
    // Stores maximum XOR value
    // by selecting path from (i, j)
    // to (i, j - 1)
    return printMaxXOR(mat, i,
                       j - 1,
                       mat[i,j] ^
                       xorValue);
  }
 
  if (j == 0)
  {
    // Stores maximum XOR value
    // by selecting path from (i, j)
    // to (i - 1, j)
    return printMaxXOR(mat,
                       i - 1, j,
                       mat[i,j] ^
                       xorValue);
  }
 
  // Stores maximum XOR value
  // by selecting path from (i, j)
  // to (i - 1, j)
  int X = printMaxXOR(mat,
                      i - 1, j,
                      mat[i,j] ^
                      xorValue);
 
  // Stores maximum XOR value
  // by selecting path from (i, j)
  // to (i, j - 1)
  int Y = printMaxXOR(mat,
                      i, j - 1,
                      mat[i,j] ^
                      xorValue);
 
  return Math.Max(X, Y);
}
   
// Driver Code
public static void Main(String[] args)
{
  int[,] mat = {{3, 2, 1},
                {6, 5, 4}, 
                {7, 8, 9}};
  int N = mat.GetLength(0);
  int M = mat.GetLength(1);
 
  // Stores bitwise XOR of
  // all elements on each
  // possible path
  int xorValue = 0;
  Console.WriteLine(printMaxXOR(mat, N - 1,
                                M - 1,
                                xorValue));
}
}
 
// This code is contributed by gauravrajput1

Javascript

 
// Javascript program to implement
// the above approach
 
function printMaxXOR(mat, i, j, xorValue)
    {
        // Base case
        if (i == 0 && j == 0)
        {
            return mat[i][j] ^ xorValue;
        }
  
        // Base case
        if (i == 0) {
  
            // Stores maximum XOR value
            // by selecting path from (i, j)
            // to (i, j - 1)
            return printMaxXOR(mat, i,
                               j - 1,
                               mat[i][j] ^ xorValue);
        }
  
        if (j == 0) {
  
            // Stores maximum XOR value
            // by selecting path from (i, j)
            // to (i - 1, j)
            return printMaxXOR(mat,
                               i - 1, j,
                               mat[i][j] ^ xorValue);
        }
  
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i - 1, j)
        let X = printMaxXOR(mat,
                            i - 1, j,
                            mat[i][j] ^ xorValue);
  
        // Stores maximum XOR value
        // by selecting path from (i, j)
        // to (i, j - 1)
        let Y = printMaxXOR(mat,
                            i, j - 1,
                            mat[i][j] ^ xorValue);
  
        return Math.max(X, Y);
    }
     
    // Driver Code
      
       let mat
            = [[ 3, 2, 1 ],
               [ 6, 5, 4 ],
               [ 7, 8, 9 ]];
        let N = mat.length;
        let M = mat[0].length;
  
        // Stores bitwise XOR of
        // all elements on each possible path
        let xorValue = 0;
        document.write(
            printMaxXOR(mat, N - 1, M - 1, xorValue));
   

输出

13

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

高效的方法：上述方法可以通过使用动态规划进行优化。dp 二维数组存储我们可以得到的行和列的maxxor 值的值。

• dp[i][j]=max(dp[i-1][j]^mat[i][j],dp[i][j-1]^mat[i][j])
• 最终结果存入dp[n-1][m-1]
• dp[i][j]=maxxor 直到第 i 行第 j 列

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
#define N 3
#define M 3
 
int printMaxXOR(int mat[][N],
                int n, int m)
{
  int dp[n + 2][m + 2];
 
  // Initialise dp 1st row
  // and 1st column
  for (int i = 0; i < n; i++)
    dp[i][0] = ((i - 1 >= 0) ?
                 dp[i - 1][0] : 0) ^
                 mat[i][0];
   
  for (int j = 0; j < m; j++)
    dp[0][j] = ((j - 1 >= 0) ?
                 dp[0][j - 1] : 0) ^
                 mat[0][j];
 
  // d[i][j] =maxXOr value you can
  //  get till ith row and jth column
  for (int i = 1; i < n; i++)
  {
    for (int j = 1; j < m; j++)
    {
      // Find the maximum value You
      // can get from the top (i-1,j)
      // and left (i,j-1)
      int X = mat[i][j] ^
              dp[i - 1][j];
      int Y = mat[i][j] ^
              dp[i][j - 1];
      dp[i][j] = max(X, Y);
    }
  }
   
  // Return the maximum
  // Xorvalue
  return dp[n - 1][m - 1];
}
 
// Driver Code
int main()
{
  int mat[M][N] = {{3, 2, 1},
                   {6, 5, 4},
                   {7, 8, 9}};
 
  // Stores bitwise XOR of
  // all elements on each
  // possible path
  int xorValue = 0;
  cout << (printMaxXOR(mat,
                       N, M));
}
 
// This code is contributed by gauravrajput1

Java

import java.io.*;
import java.util.*;
class GFG {
    public static int printMaxXOR(int[][] mat,
                                  int n, int m)
    {
        int dp[][] = new int[n + 2][m + 2];
 
        // Initialise dp 1st row and 1st column
        for (int i = 0; i < n; i++)
            dp[i][0] = ((i - 1 >= 0)
                       ? dp[i - 1][0] : 0)
                       ^ mat[i][0];
        for (int j = 0; j < m; j++)
            dp[0][j] = ((j - 1 >= 0)
                       ? dp[0][j - 1] : 0)
                       ^ mat[0][j];
         
        // d[i][j] =maxXOr value you can
        //  get till ith row and jth column
        for (int i = 1; i < n; i++)
        {
            for (int j = 1; j < m; j++)
            {
                // Find the maximum value You
                // can get from the top (i-1,j)
                // and left (i,j-1)
                int X = mat[i][j] ^ dp[i - 1][j];
                int Y = mat[i][j] ^ dp[i][j - 1];
                dp[i][j] = Math.max(X, Y);
            }
        }
        // Return the maximum Xorvalue
        return dp[n - 1][m - 1];
    }
   
    // Driver Code
    public static void main(String[] args)
    {
 
        int[][] mat
            = { { 3, 2, 1 },
               { 6, 5, 4 },
               { 7, 8, 9 } };
        int N = mat.length;
        int M = mat[0].length;
 
        // Stores bitwise XOR of
        // all elements on each possible path
        int xorValue = 0;
        System.out.println(printMaxXOR(mat, N, M));
    }
    // This code is contributed by hemanth gadarla
}

蟒蛇3

# Python3 program for the
# above approach
def printMaxXOR(mat, n, m):
   
    dp = [[0 for i in range(m+2)]
             for j in range(n+2)];
 
    # Initialise dp 1st row and
    # 1st column
    for i in range(n):
        if((i - 1) >= 0):
            dp[i][0] = (dp[i - 1][0] ^
                        mat[i][0]);
        else:
            dp[i][0] =  0 ^ mat[i][0];
             
    for j in range(m):
        if((j - 1) >= 0):
            dp[0][j] = (dp[0][j - 1] ^
                        mat[0][j]);
        else:
            dp[0][j] = 0 ^ mat[0][j];
             
    # d[i][j] = maxXOr value you can
    # get till ith row and jth column
    for i in range(1, n):
        for j in range(1, m):
           
            # Find the maximum value You
            # can get from the top (i-1,j)
            # and left (i,j-1)
            X = (mat[i][j] ^
                 dp[i - 1][j]);
            Y = (mat[i][j] ^
                 dp[i][j - 1]);
            dp[i][j] = max(X, Y);
 
    # Return the maximum
    # Xorvalue
    return dp[n - 1][m - 1];
 
# Driver Code
if __name__ == '__main__':
   
    mat = [[3, 2, 1],
           [6, 5, 4],
           [7, 8, 9]];
    N = len(mat);
    M = len(mat[0]);
 
    # Stores bitwise XOR of
    # all elements on each
    # possible path
    xorValue = 0;
    print(printMaxXOR(mat, N, M));
 
# This code is contributed by gauravrajput1

C＃

// C# Program for the
// above approach
using System;
class GFG{
   
public static int printMaxXOR(int[,] mat,
                              int n, int m)
{
  int [,]dp = new int[n + 2, m + 2];
 
  // Initialise dp 1st row and
  // 1st column
  for (int i = 0; i < n; i++)
    dp[i, 0] = ((i - 1 >= 0) ?
                 dp[i - 1, 0] : 0) ^
                 mat[i, 0];
   
  for (int j = 0; j < m; j++)
    dp[0, j] = ((j - 1 >= 0) ?
                 dp[0, j - 1] : 0) ^
                 mat[0, j];
 
  // d[i,j] =maxXOr value you can
  //  get till ith row and jth column
  for (int i = 1; i < n; i++)
  {
    for (int j = 1; j < m; j++)
    {
      // Find the maximum value You
      // can get from the top (i-1,j)
      // and left (i,j-1)
      int X = mat[i, j] ^ dp[i - 1, j];
      int Y = mat[i, j] ^ dp[i, j - 1];
      dp[i, j] = Math.Max(X, Y);
    }
  }
  // Return the maximum Xorvalue
  return dp[n - 1, m - 1];
}
 
// Driver Code
public static void Main(String[] args)
{
  int[,] mat = {{3, 2, 1},
                {6, 5, 4},
                {7, 8, 9}};
  int N = mat.GetLength(0);
  int M = mat.GetLength(1);
 
  // Stores bitwise XOR of
  // all elements on each
  // possible path
  int xorValue = 0;
  Console.WriteLine(printMaxXOR(mat,
                                N, M));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

// Javascript program for the above approach
 
N = 3;
M = 3;
 
function printMaxXOR(mat, n, m)
{
//  var dp[n + 2][m + 2];
  var dp = new Array(n+2).fill(0).map(item =>(new Array(m+2).fill(0)));
 
  // Initialise dp 1st row
  // and 1st column
  for (var i = 0; i < n; i++)
    dp[i][0] = ((i - 1 >= 0) ? dp[i - 1][0] : 0) ^ mat[i][0];
   
  for (var j = 0; j < m; j++)
    dp[0][j] = ((j - 1 >= 0) ? dp[0][j - 1] : 0) ^ mat[0][j];
 
  // d[i][j] =maxXOr value you can
  //  get till ith row and jth column
  for (var i = 1; i < n; i++)
  {
    for (var j = 1; j < m; j++)
    {
      // Find the maximum value You
      // can get from the top (i-1,j)
      // and left (i,j-1)
      var X = mat[i][j] ^ dp[i - 1][j];
      var Y = mat[i][j] ^ dp[i][j - 1];
      dp[i][j] = Math.max(X, Y);
    }
  }
   
  // Return the maximum
  // Xorvalue
  return dp[n - 1][m - 1];
}
 
 var mat = [[3, 2, 1],
            [6, 5, 4],
            [7, 8, 9]];
 
  // Stores bitwise XOR of
  // all elements on each
  // possible path
  var xorValue = 0;
  document.write(printMaxXOR(mat, N, M));
 
 
//This code is contributed by SoumikMondal

输出

13

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

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