Count of Possible paths of given Matrix having Bitwise XOR equal to K

// Java code to implement the above approach
import java.util.*;

class GFG{

  static int  n, m, k , ans;
  static int [][]mat;

  // Backtracking to find the path count
  static void backtracking(int i, int j, int zor)
  {
    // If the bottom-right ceint is reached
    if (i == n - 1 && j == m - 1) {

      // If XOR value is k
      if (zor == k)
        ans++;
      return;
    }

    // Move rightwards
    if (j + 1 < m)
      backtracking(i, j + 1, 
                   zor ^ mat[i][j + 1]);

    // Move downwards
    if (i + 1 < n)
      backtracking(i + 1, j, 
                   zor ^ mat[i + 1][j]);
  }

  // Function to calculate all possible paths
  static int countPaths(int N, int M, int K)
  {
    ans = 0;
    n = N; m = M; k = K;
    if (N == 1 && M == 1 
        && mat[0][0] == K) {
      return 1;
    }

    // Calling the backtracking function
    backtracking(0, 0, mat[0][0]);
    return ans;
  }

  // Driver Code
  public static void main(String[] args)
  {
    int N = 3, M = 3, K = 11;
    mat = new int[][]{ {2, 1, 5}, {7, 10, 0}, 
                      {12, 6, 4} };

    // Function call
    int ans = countPaths(N, M, K);
    System.out.print(ans+ "\n");
  }
}

// This code is contributed by 29AjayKumar 

import java.util.HashMap;
import java.util.Map;

public class PathCount {
    static int cnt1, cnt2;
    static Map<String, Integer> mp1 = new HashMap<>();
    static Map<String, Integer> mp2 = new HashMap<>();
    static int[][] a;
    static int n, m, k;

    // Backtracking function for the left part
    static void part1(int i, int j, int cnt, int zor) {
        if (cnt <= 0) {
            // Count the number of triplets
            String key = zor + "," + i + "," + j;
            mp1.put(key, mp1.getOrDefault(key, 0) + 1);
            return;
        }

        // Move rightwards
        if (j + 1 < m) {
            part1(i, j + 1, cnt - 1, zor ^ a[i][j + 1]);
        }

        // Move downwards
        if (i + 1 < n) {
            part1(i + 1, j, cnt - 1, zor ^ a[i + 1][j]);
        }
    }

    // Backtracking function for the right part
    static void part2(int i, int j, int cnt, int zor) {
        if (cnt <= 0) {
            // Count the number of triplets
            String key = zor + "," + i + "," + j;
            mp2.put(key, mp2.getOrDefault(key, 0) + 1);
            return;
        }

        // Move leftwards
        if (j - 1 >= 0) {
            part2(i, j - 1, cnt - 1, zor ^ a[i][j - 1]);
        }

        // Move upwards
        if (i - 1 >= 0) {
            part2(i - 1, j, cnt - 1, zor ^ a[i - 1][j]);
        }
    }

    // Function to count the paths with xor K
    static int countPaths(int N, int M, int K) {
        int ans = 0;
        n = N;
        m = M;
        k = K;

        // Number of steps for left part
        cnt1 = (n + m - 2) / 2;

        // Number of steps for the right part
        cnt2 = (n + m - 2) - cnt1;

        // number of steps in both parts are 0
        if (n == 1 && m == 1 && a[0][0] == k) {
            return 1;
        }

        // Calling the recursive function for the left and right part
        part1(0, 0, cnt1, a[0][0]);
        part2(n - 1, m - 1, cnt2 - 1, a[n - 1][m - 1]);

        // mp2 contains triplets of the right part, so traverse the triplets of the right part
        for (String key : mp2.keySet()) {
            // Extracting all elements from the triplet
            String[] parts = key.split(",");
            int zor = Integer.parseInt(parts[0]);
            int idx = Integer.parseInt(parts[1]);
            int j = Integer.parseInt(parts[2]);
            int cnt = mp2.get(key);

            // XOR OF RIGHT SIDE IS zor,
            // then XOR of the left side
            // must be zor^k such that XOR
            // of the total path is K
            int required = k ^ zor;

            // Checking if one index to the left
            // are left triplets and how many paths
            String leftKey1 = required + "," + idx + "," + (j - 1);
            if (j - 1 >= 0 && mp1.containsKey(leftKey1)) {
                // Total path would be paths in left * paths in right
                ans += cnt * mp1.get(leftKey1);
            }

            // Checking if one index upwards
            // are left triplets and how many paths
            String leftKey2 = required + "," + (idx - 1) + "," + j;
            if (idx - 1 >= 0 && mp1.containsKey(leftKey2)) {
                // Total path would be paths in left * paths in right
                ans += cnt * mp1.get(leftKey2);
            }
        }

        return ans;
    }

    public static void main(String[] args) {
        n = 3;
        m = 3;
        k = 11;
        a = new int[][]{
                {2, 1, 5},
                {7, 10, 0},
                {12, 6, 4}
        };

        // Function call
        int ans = countPaths(n, m, k);
        System.out.println(ans);
    }
}