Maximum XOR of a path from top-left to bottom-right cell of given Matrix

Given a matrix, mat[][] of dimensions N * M, the task is to print the maximum bitwise XOR value that can be obtained for a path from the top-left cell (0, 0) to the bottom-right cell (N – 1, M – 1) of the given matrix. Only possible moves from any cell (i, j) is (i + 1, j) and (i, j + 1)
Note: Bitwise XOR value of a path is defined as bitwise XOR of all possible elements on that path.

Examples:

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, maximum bitwise XOR value from all possible paths is 13. 
 

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

Approach: The idea is to generate all possible paths from the top-left cell (0, 0) to the bottom-right cell (N – 1, M – 1) of the given matrix using Recursion and print the maximum XOR value of all possible paths. Following are the recurrence relations and their base cases:



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)  

Follow the steps below to solve the problem:

  • Initialize a variable, say xorValue to store the bitwise XOR of all possible elements on the path from the top-left cell (0, 0) to the bottom-right cell (N – 1, M – 1).
  • Use the above recurrence relation to find the maximum XOR value of all possible paths from the top-left cell (0, 0) to the bottom-right cell (N – 1, M – 1).
  • Finally, print the value maximum XOR value of all possible paths from the top-left cell (0, 0) to the bottom-right cell (N – 1, M – 1).

 Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print maximum XOR
// value of all possible path
// from (0, 0) to (N - 1, M - 1)
int printMaxXOR(vector<vector<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 max(X, Y);
}
 
// Driver Code
int main()
{
    vector<vector<int> > 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output

13




Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach:The above approach can be optimized by using dynamic programming.The dp 2-dimensional array stores values of maxxor value we can get till that row and column.

  • dp[i][j]=max(dp[i-1][j]^mat[i][j] ,dp[i][j-1]^mat[i][j])
  • the finsal result is stored in dp[n-1][m-1]
  • dp[i][j]=maxxor till ith row and jth coloumn

Below is the implementation of above approach :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output

13





Time Complexity: O(N*M)
Auxiliary space Complexity :O(N*M)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


Still Learner

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.