Longest Possible Route in a Matrix with Hurdles

// Java program to find Longest Possible Route in a
// matrix with hurdles
import java.io.*;

class GFG {
  static int R = 3;
  static int C = 10;

  // A Pair to store status of a cell. found is set to
  // true of destination is reachable and value stores
  // distance of longest path
  static class Pair {

    // true if destination is found
    boolean found;

    // stores cost of longest path from current cell to
    // destination cell
    int val;

    Pair (boolean x, int y){
      found = x;
      val = y;
    }
  }

  // Function to find Longest Possible Route in the
  // matrix with hurdles. If the destination is not reachable
  // the function returns false with cost Integer.MAX_VALUE.
  // (i, j) is source cell and (x, y) is destination cell.

  static Pair findLongestPathUtil (int mat[][], int i, int j, int x, int y, boolean visited[][]) {

    // if (i, j) itself is destination, return true
    if(i == x && j == y)
      return new Pair(true, 0);


    // if not a valid cell, return false  
    if(i < 0 || i >= R || j < 0 || j >= C || mat[i][j] == 0 || visited[i][j] )
      return new Pair(false, Integer.MAX_VALUE);

    // include (i, j) in current path i.e.
    // set visited(i, j) to true
    visited[i][j] = true;

    // res stores longest path from current cell (i, j) to
    // destination cell (x, y)
    int res = Integer.MIN_VALUE;

    // go left from current cell
    Pair sol = findLongestPathUtil(mat, i, j-1, x, y, visited);

    // if destination can be reached on going left from current
    // cell, update res
    if(sol.found)
      res = Math.max(sol.val, res);

    // go right from current cell
    sol = findLongestPathUtil(mat, i, j+1, x, y, visited);

    // if destination can be reached on going right from current
    // cell, update res
    if(sol.found)
      res = Math.max(sol.val, res);

    // go up from current cell
    sol = findLongestPathUtil(mat, i-1, j, x, y, visited);

    // if destination can be reached on going up from current
    // cell, update res
    if(sol.found)
      res = Math.max(sol.val, res);

    // go down from current cell
    sol = findLongestPathUtil(mat, i+1, j, x, y, visited);

    // if destination can be reached on going down from current
    // cell, update res
    if(sol.found)
      res = Math.max(sol.val, res);

    // Backtrack
    visited[i][j] = false;

    // if destination can be reached from current cell,
    // return true
    if(res != Integer.MIN_VALUE)
      return new Pair(true, res+1);

    // if destination can't be reached from current cell,
    // return false
    else
      return new Pair(false, Integer.MAX_VALUE);

  }  

  // A wrapper function over findLongestPathUtil()
  static void findLongestPath (int mat[][], int i, int j, int x, int y) {

    // create a boolean matrix to store info about
    // cells already visited in current route
    boolean visited[][] = new boolean[R][C];


    // find longest route from (i, j) to (x, y) and
    // print its maximum cost
    Pair p = findLongestPathUtil(mat, i, j, x, y, visited);

    if(p.found)
      System.out.println("Length of longest possible route is " + p.val);

    // If the destination is not reachable
    else
      System.out.println("Destination not reachable from given source");

  }


  // Driver Code
  public static void main (String[] args) {

    // input matrix with hurdles shown with number 0
    int mat[][] = { { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
                   { 1, 1, 0, 1, 1, 0, 1, 1, 0, 1 },
                   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } };

    // find longest path with source (0, 0) and
    // destination (1, 7)
    findLongestPath(mat, 0, 0, 1, 7);

  }
}

// This code is contributed by th_aditi.

public class Main {
    // Function for finding the longest path
    // 'ans' is -1 if we can't reach
    // 'cur' is the number of steps we have traversed
    public static int findLongestPath(int[][] mat, int i,
                                      int j, int di, int dj,
                                      int n, int m, int cur,
                                      int ans)
    {
        // If we reach the destination
        if (i == di && j == dj) {
            // If current path steps are more than previous
            // path steps
            if (cur > ans)
                ans = cur;
            return ans;
        }

          //if the source or destination is a hurdle itself
          if(mat[i][j]==0 || mat[di][dj]==0) return ans;
      
        // Mark as visited
        mat[i][j] = 0;

        // Checking if we can reach the destination going
        // right
        if (j != m - 1 && mat[i][j + 1] > 0)
            ans = findLongestPath(mat, i, j + 1, di, dj, n,
                                  m, cur + 1, ans);

        // Checking if we can reach the destination going
        // down
        if (i != n - 1 && mat[i + 1][j] > 0)
            ans = findLongestPath(mat, i + 1, j, di, dj, n,
                                  m, cur + 1, ans);

        // Checking if we can reach the destination going
        // left
        if (j != 0 && mat[i][j - 1] > 0)
            ans = findLongestPath(mat, i, j - 1, di, dj, n,
                                  m, cur + 1, ans);

        // Checking if we can reach the destination going up
        if (i != 0 && mat[i - 1][j] > 0)
            ans = findLongestPath(mat, i - 1, j, di, dj, n,
                                  m, cur + 1, ans);

        // Marking visited to backtrack
        mat[i][j] = 1;

        // Returning the answer we got so far
        return ans;
    }

    public static void main(String[] args)
    {
        int[][] mat = { { 1, 1, 1, 1 },
                        { 1, 1, 0, 1 },
                        { 1, 1, 1, 1 } };

        // Find the longest path with source (0, 0) and
        // destination (2, 3)
        int result
            = findLongestPath(mat, 0, 0, 2, 3, mat.length,
                              mat[0].length, 0, -1);
        System.out.println(result);
    }
}