Find shortest safe route in a path with landmines - GeeksforGeeks

05 Aug, 2021
Given a path in the form of a rectangular matrix having few landmines arbitrarily placed (marked as 0), calculate length of the shortest safe route possible from any cell in the first column to any cell in the last column of the matrix. We have to avoid landmines and their four adjacent cells (left, right, above and below) as they are also unsafe. We are allowed to move to only adjacent cells which are not landmines. i.e. the route cannot contains any diagonal moves.
Examples:  
Input: 
A 12 x 10 matrix with landmines marked as 0

[ 1  1  1  1  1  1  1  1  1  1 ]
[ 1  0  1  1  1  1  1  1  1  1 ]
[ 1  1  1  0  1  1  1  1  1  1 ]
[ 1  1  1  1  0  1  1  1  1  1 ]
[ 1  1  1  1  1  1  1  1  1  1 ]
[ 1  1  1  1  1  0  1  1  1  1 ]
[ 1  0  1  1  1  1  1  1  0  1 ]
[ 1  1  1  1  1  1  1  1  1  1 ]
[ 1  1  1  1  1  1  1  1  1  1 ]
[ 0  1  1  1  1  0  1  1  1  1 ]
[ 1  1  1  1  1  1  1  1  1  1 ]
[ 1  1  1  0  1  1  1  1  1  1 ]

Output:  
Length of shortest safe route is 13 (Highlighted in Bold)
The idea is to use Backtracking. We first mark all adjacent cells of the landmines as unsafe. Then for each safe cell of first column of the matrix, we move forward in all allowed directions and recursively checks if they leads to the destination or not. If destination is found, we update the value of shortest path else if none of the above solutions work we return false from our function.
Below is the implementation of above idea –
C++
Java
Python3
C#
Javascript
// C++ program to find shortest safe Route in// the matrix with landmines#include <bits/stdc++.h>using namespace std;#define R 12#define C 10 // These arrays are used to get row and column// numbers of 4 neighbours of a given cellint rowNum[] = { -1, 0, 0, 1 };int colNum[] = { 0, -1, 1, 0 }; // A function to check if a given cell (x, y)// can be visited or notbool isSafe(int mat[R][C], int visited[R][C],            int x, int y){    if (mat[x][y] == 0 || visited[x][y])        return false;     return true;} // A function to check if a given cell (x, y) is// a valid cell or notbool isValid(int x, int y){    if (x < R && y < C && x >= 0 && y >= 0)        return true;     return false;} // A function to mark all adjacent cells of// landmines as unsafe. Landmines are shown with// number 0void markUnsafeCells(int mat[R][C]){    for (int i = 0; i < R; i++)    {        for (int j = 0; j < C; j++)        {            // if a landmines is found            if (mat[i][j] == 0)            {              // mark all adjacent cells              for (int k = 0; k < 4; k++)                if (isValid(i + rowNum[k], j + colNum[k]))                    mat[i + rowNum[k]][j + colNum[k]] = -1;            }        }    }     // mark all found adjacent cells as unsafe    for (int i = 0; i < R; i++)    {        for (int j = 0; j < C; j++)        {            if (mat[i][j] == -1)                mat[i][j] = 0;        }    }     // Uncomment below lines to print the path    /*for (int i = 0; i < R; i++)    {        for (int j = 0; j < C; j++)        {            cout << std::setw(3) << mat[i][j];        }        cout << endl;    }*/} // Function to find shortest safe Route in the// matrix with landmines// mat[][] - binary input matrix with safe cells marked as 1// visited[][] - store info about cells already visited in// current route// (i, j) are coordinates of the current cell// min_dist --> stores minimum cost of shortest path so far// dist --> stores current path costvoid findShortestPathUtil(int mat[R][C], int visited[R][C],                          int i, int j, int &min_dist, int dist){    // if destination is reached    if (j == C-1)    {        // update shortest path found so far        min_dist = min(dist, min_dist);        return;    }     // if current path cost exceeds minimum so far    if (dist > min_dist)        return;     // include (i, j) in current path    visited[i][j] = 1;     // Recurse for all safe adjacent neighbours    for (int k = 0; k < 4; k++)    {        if (isValid(i + rowNum[k], j + colNum[k]) &&            isSafe(mat, visited, i + rowNum[k], j + colNum[k]))        {            findShortestPathUtil(mat, visited, i + rowNum[k],                           j + colNum[k], min_dist, dist + 1);        }    }     // Backtrack    visited[i][j] = 0;} // A wrapper function over findshortestPathUtil()void findShortestPath(int mat[R][C]){    // stores minimum cost of shortest path so far    int min_dist = INT_MAX;     // create a boolean matrix to store info about    // cells already visited in current route    int visited[R][C];     // mark adjacent cells of landmines as unsafe    markUnsafeCells(mat);     // start from first column and take minimum    for (int i = 0; i < R; i++)    {        // if path is safe from current cell        if (mat[i][0] == 1)        {            // initialize visited to false            memset(visited, 0, sizeof visited);             // find shortest route from (i, 0) to any            // cell of last column (x, C - 1) where            // 0 <= x < R            findShortestPathUtil(mat, visited, i, 0,                                 min_dist, 0);             // if min distance is already found            if(min_dist == C - 1)                break;        }    }     // if destination can be reached    if (min_dist != INT_MAX)        cout << "Length of shortest safe route is "             << min_dist;     else // if the destination is not reachable        cout << "Destination not reachable from "             << "given source";} // Driver codeint main(){    // input matrix with landmines shown with number 0    int mat[R][C] =    {        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 }    };     // find shortest path    findShortestPath(mat);     return 0;}
// Java program to find shortest safe Route// in the matrix with landminesimport java.util.Arrays; class GFG{ static final int R = 12;static final int C = 10; // These arrays are used to get row and column// numbers of 4 neighbours of a given cellstatic int rowNum[] = { -1, 0, 0, 1 };static int colNum[] = { 0, -1, 1, 0 }; static int min_dist; // A function to check if a given cell (x, y)// can be visited or notstatic boolean isSafe(int[][] mat, boolean[][] visited,                      int x, int y){    if (mat[x][y] == 0 || visited[x][y])        return false;     return true;} // A function to check if a given cell (x, y) is// a valid cell or notstatic boolean isValid(int x, int y){    if (x < R && y < C && x >= 0 && y >= 0)        return true;     return false;} // A function to mark all adjacent cells of// landmines as unsafe. Landmines are shown with// number 0static void markUnsafeCells(int[][] mat){    for(int i = 0; i < R; i++)    {        for(int j = 0; j < C; j++)        {                         // If a landmines is found            if (mat[i][j] == 0)            {                                 // Mark all adjacent cells                for(int k = 0; k < 4; k++)                    if (isValid(i + rowNum[k], j + colNum[k]))                        mat[i + rowNum[k]][j + colNum[k]] = -1;            }        }    }     // Mark all found adjacent cells as unsafe    for(int i = 0; i < R; i++)    {        for(int j = 0; j < C; j++)        {            if (mat[i][j] == -1)                mat[i][j] = 0;        }    }     // Uncomment below lines to print the path    /*     * for (int i = 0; i < R; i++) {     * for (int j = 0; j < C; j++) { cout <<     * std::setw(3) << mat[i][j]; } cout << endl; }     */} // Function to find shortest safe Route in the// matrix with landmines// mat[][] - binary input matrix with safe cells marked as 1// visited[][] - store info about cells already visited in// current route// (i, j) are coordinates of the current cell// min_dist --> stores minimum cost of shortest path so far// dist --> stores current path coststatic void findShortestPathUtil(int[][] mat,                                 boolean[][] visited,                                 int i, int j, int dist){         // If destination is reached    if (j == C - 1)    {                 // Update shortest path found so far        min_dist = Math.min(dist, min_dist);        return;    }         // If current path cost exceeds minimum so far    if (dist > min_dist)        return;     // include (i, j) in current path    visited[i][j] = true;     // Recurse for all safe adjacent neighbours    for(int k = 0; k < 4; k++)    {        if (isValid(i + rowNum[k], j + colNum[k]) &&            isSafe(mat, visited, i + rowNum[k],                                 j + colNum[k]))        {            findShortestPathUtil(mat, visited, i + rowNum[k],                             j + colNum[k], dist + 1);        }    }     // Backtrack    visited[i][j] = false;} // A wrapper function over findshortestPathUtil()static void findShortestPath(int[][] mat){         // Stores minimum cost of shortest path so far    min_dist = Integer.MAX_VALUE;         // Create a boolean matrix to store info about    // cells already visited in current route    boolean[][] visited = new boolean[R][C];     // Mark adjacent cells of landmines as unsafe    markUnsafeCells(mat);     // Start from first column and take minimum    for(int i = 0; i < R; i++)    {                 // If path is safe from current cell        if (mat[i][0] == 1)        {                         // Initialize visited to false            for(int k = 0; k < R; k++)            {                Arrays.fill(visited[k], false);            }             // Find shortest route from (i, 0) to any            // cell of last column (x, C - 1) where            // 0 <= x < R            findShortestPathUtil(mat, visited, i, 0, 0);             // If min distance is already found            if (min_dist == C - 1)                break;        }    }         // If destination can be reached    if (min_dist != Integer.MAX_VALUE)        System.out.println("Length of shortest " +                           "safe route is " + min_dist);     else             // If the destination is not reachable        System.out.println("Destination not " +                           "reachable from given source");} // Driver codepublic static void main(String[] args){         // Input matrix with landmines shown with number 0    int[][] mat = {        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 } };     // Find shortest path    findShortestPath(mat);}} // This code is contributed by sanjeev2552
# Python3 program to find shortest safe Route# in the matrix with landminesimport sys R = 12C = 10 # These arrays are used to get row and column# numbers of 4 neighbours of a given cellrowNum = [ -1, 0, 0, 1 ]colNum = [ 0, -1, 1, 0 ] min_dist = sys.maxsize # A function to check if a given cell (x, y)# can be visited or notdef isSafe(mat, visited, x, y):     if (mat[x][y] == 0 or visited[x][y]):        return False     return True # A function to check if a given cell (x, y) is# a valid cell or notdef isValid(x, y):     if (x < R and y < C and x >= 0 and y >= 0):        return True     return False # A function to mark all adjacent cells of# landmines as unsafe. Landmines are shown with# number 0def markUnsafeCells(mat):     for i in range(R):        for j in range(C):            # If a landmines is found            if (mat[i][j] == 0):                # Mark all adjacent cells                for k in range(4):                    if (isValid(i + rowNum[k], j + colNum[k])):                        mat[i + rowNum[k]][j + colNum[k]] = -1     # Mark all found adjacent cells as unsafe    for i in range(R):        for j in range(C):            if (mat[i][j] == -1):                mat[i][j] = 0     """ Uncomment below lines to print the path    /*     * for (int i = 0; i < R; i++) {     * for (int j = 0; j < C; j++) { cout <<     * std::setw(3) << mat[i][j]; } cout << endl; }     *""" # Function to find shortest safe Route in the# matrix with landmines# mat[][] - binary input matrix with safe cells marked as 1# visited[][] - store info about cells already visited in# current route# (i, j) are coordinates of the current cell# min_dist --> stores minimum cost of shortest path so far# dist --> stores current path costdef findShortestPathUtil(mat, visited, i, j, dist):         global min_dist     # If destination is reached    if (j == C - 1):        # Update shortest path found so far        min_dist = min(dist, min_dist)        return     # If current path cost exceeds minimum so far    if (dist > min_dist):        return     # include (i, j) in current path    visited[i][j] = True     # Recurse for all safe adjacent neighbours    for k in range(4):        if (isValid(i + rowNum[k], j + colNum[k]) and isSafe(mat, visited, i + rowNum[k], j + colNum[k])):            findShortestPathUtil(mat, visited, i + rowNum[k], j + colNum[k], dist + 1)     # Backtrack    visited[i][j] = False # A wrapper function over findshortestPathUtil()def findShortestPath(mat):         global min_dist     # Stores minimum cost of shortest path so far    min_dist = sys.maxsize     # Create a boolean matrix to store info about    # cells already visited in current route    visited = [[False for i in range(C)] for j in range(R)]     # Mark adjacent cells of landmines as unsafe    markUnsafeCells(mat)     # Start from first column and take minimum    for i in range(R):        # If path is safe from current cell        if (mat[i][0] == 1):            # Find shortest route from (i, 0) to any            # cell of last column (x, C - 1) where            # 0 <= x < R            findShortestPathUtil(mat, visited, i, 0, 0)             # If min distance is already found            if (min_dist == C - 1):                break     # If destination can be reached    if (min_dist != sys.maxsize):        print("Length of shortest safe route is", min_dist)    else:        # If the destination is not reachable        print("Destination not reachable from given source")         mat = [        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 ],        [ 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 ] ]   # Find shortest pathfindShortestPath(mat) # This code is contributed by mukesh07.
// C# program to find shortest safe Route// in the matrix with landminesusing System;using System.Collections.Generic;class GFG {         static int R = 12;    static int C = 10;          // These arrays are used to get row and column    // numbers of 4 neighbours of a given cell    static int[] rowNum = { -1, 0, 0, 1 };    static int[] colNum = { 0, -1, 1, 0 };          static int min_dist;          // A function to check if a given cell (x, y)    // can be visited or not    static bool isSafe(int[,] mat, bool[,] visited, int x, int y)    {        if (mat[x,y] == 0 || visited[x,y])            return false;              return true;    }          // A function to check if a given cell (x, y) is    // a valid cell or not    static bool isValid(int x, int y)    {        if (x < R && y < C && x >= 0 && y >= 0)            return true;              return false;    }          // A function to mark all adjacent cells of    // landmines as unsafe. Landmines are shown with    // number 0    static void markUnsafeCells(int[,] mat)    {        for(int i = 0; i < R; i++)        {            for(int j = 0; j < C; j++)            {                                  // If a landmines is found                if (mat[i,j] == 0)                {                                          // Mark all adjacent cells                    for(int k = 0; k < 4; k++)                        if (isValid(i + rowNum[k], j + colNum[k]))                            mat[i + rowNum[k],j + colNum[k]] = -1;                }            }        }              // Mark all found adjacent cells as unsafe        for(int i = 0; i < R; i++)        {            for(int j = 0; j < C; j++)            {                if (mat[i,j] == -1)                    mat[i,j] = 0;            }        }              // Uncomment below lines to print the path        /*         * for (int i = 0; i < R; i++) {         * for (int j = 0; j < C; j++) { cout <<         * std::setw(3) << mat[i][j]; } cout << endl; }         */    }          // Function to find shortest safe Route in the    // matrix with landmines    // mat[][] - binary input matrix with safe cells marked as 1    // visited[][] - store info about cells already visited in    // current route    // (i, j) are coordinates of the current cell    // min_dist --> stores minimum cost of shortest path so far    // dist --> stores current path cost    static void findShortestPathUtil(int[,] mat,                                     bool[,] visited,                                     int i, int j, int dist)    {                  // If destination is reached        if (j == C - 1)        {                          // Update shortest path found so far            min_dist = Math.Min(dist, min_dist);            return;        }                  // If current path cost exceeds minimum so far        if (dist > min_dist)            return;              // include (i, j) in current path        visited[i,j] = true;              // Recurse for all safe adjacent neighbours        for(int k = 0; k < 4; k++)        {            if (isValid(i + rowNum[k], j + colNum[k]) &&                isSafe(mat, visited, i + rowNum[k], j + colNum[k]))            {                findShortestPathUtil(mat, visited, i + rowNum[k], j + colNum[k], dist + 1);            }        }              // Backtrack        visited[i,j] = false;    }          // A wrapper function over findshortestPathUtil()    static void findShortestPath(int[,] mat)    {                  // Stores minimum cost of shortest path so far        min_dist = Int32.MaxValue;                  // Create a boolean matrix to store info about        // cells already visited in current route        bool[,] visited = new bool[R,C];              // Mark adjacent cells of landmines as unsafe        markUnsafeCells(mat);              // Start from first column and take minimum        for(int i = 0; i < R; i++)        {                          // If path is safe from current cell            if (mat[i,0] == 1)            {                // Find shortest route from (i, 0) to any                // cell of last column (x, C - 1) where                // 0 <= x < R                findShortestPathUtil(mat, visited, i, 0, 0);                      // If min distance is already found                if (min_dist == C - 1)                    break;            }        }                  // If destination can be reached        if (min_dist != Int32.MaxValue)            Console.WriteLine("Length of shortest " +                               "safe route is " + min_dist);              else                      // If the destination is not reachable            Console.WriteLine("Destination not " +                               "reachable from given source");    }       static void Main()  {         // Input matrix with landmines shown with number 0    int[,] mat = {        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 } };      // Find shortest path    findShortestPath(mat);  }} // This code is contributed by rameshtravel07.
<script>    // Javascript program to find shortest safe Route    // in the matrix with landmines         let R = 12;    let C = 10;     // These arrays are used to get row and column    // numbers of 4 neighbours of a given cell    let rowNum = [ -1, 0, 0, 1 ];    let colNum = [ 0, -1, 1, 0 ];     let min_dist;     // A function to check if a given cell (x, y)    // can be visited or not    function isSafe(mat, visited, x, y)    {        if (mat[x][y] == 0 || visited[x][y])            return false;         return true;    }     // A function to check if a given cell (x, y) is    // a valid cell or not    function isValid(x, y)    {        if (x < R && y < C && x >= 0 && y >= 0)            return true;         return false;    }     // A function to mark all adjacent cells of    // landmines as unsafe. Landmines are shown with    // number 0    function markUnsafeCells(mat)    {        for(let i = 0; i < R; i++)        {            for(let j = 0; j < C; j++)            {                 // If a landmines is found                if (mat[i][j] == 0)                {                     // Mark all adjacent cells                    for(let k = 0; k < 4; k++)                        if (isValid(i + rowNum[k], j + colNum[k]))                            mat[i + rowNum[k]][j + colNum[k]] = -1;                }            }        }         // Mark all found adjacent cells as unsafe        for(let i = 0; i < R; i++)        {            for(let j = 0; j < C; j++)            {                if (mat[i][j] == -1)                    mat[i][j] = 0;            }        }         // Uncomment below lines to print the path        /*         * for (int i = 0; i < R; i++) {         * for (int j = 0; j < C; j++) { cout <<         * std::setw(3) << mat[i][j]; } cout << endl; }         */    }     // Function to find shortest safe Route in the    // matrix with landmines    // mat[][] - binary input matrix with safe cells marked as 1    // visited[][] - store info about cells already visited in    // current route    // (i, j) are coordinates of the current cell    // min_dist --> stores minimum cost of shortest path so far    // dist --> stores current path cost    function findShortestPathUtil(mat, visited, i, j, dist)    {         // If destination is reached        if (j == C - 1)        {             // Update shortest path found so far            min_dist = Math.min(dist, min_dist);            return;        }         // If current path cost exceeds minimum so far        if (dist > min_dist)            return;         // include (i, j) in current path        visited[i][j] = true;         // Recurse for all safe adjacent neighbours        for(let k = 0; k < 4; k++)        {            if (isValid(i + rowNum[k], j + colNum[k]) &&                isSafe(mat, visited, i + rowNum[k],                                     j + colNum[k]))            {                findShortestPathUtil(mat, visited, i + rowNum[k],                                 j + colNum[k], dist + 1);            }        }         // Backtrack        visited[i][j] = false;    }     // A wrapper function over findshortestPathUtil()    function findShortestPath(mat)    {         // Stores minimum cost of shortest path so far        min_dist = Number.MAX_VALUE;         // Create a boolean matrix to store info about        // cells already visited in current route        let visited = new Array(R);                 for(let i = 0; i < R; i++)        {            visited[i] = new Array(C);            for(let j = 0; j < C; j++)            {                visited[i][j] = false;            }        }         // Mark adjacent cells of landmines as unsafe        markUnsafeCells(mat);         // Start from first column and take minimum        for(let i = 0; i < R; i++)        {            // If path is safe from current cell            if (mat[i][0] == 1)            {                 // Find shortest route from (i, 0) to any                // cell of last column (x, C - 1) where                // 0 <= x < R                findShortestPathUtil(mat, visited, i, 0, 0);                 // If min distance is already found                if (min_dist == C - 1)                    break;            }        }         // If destination can be reached        if (min_dist != Number.MAX_VALUE)            document.write("Length of shortest " +                               "safe route is " + min_dist + "</br>");         else             // If the destination is not reachable            document.write("Destination not " +                               "reachable from given source" + "</br>");    }         // Input matrix with landmines shown with number 0    let mat = [        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 ],        [ 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 ],        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],        [ 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 ] ];      // Find shortest path    findShortestPath(mat); // This code is contributed by decode2207.</script>
Output: 
Length of shortest safe route is 13
Another method: It can be solved in polynomial time with the help of Breadth First Search. Enqueue the cells with 1 value in the queue with the distance as 0. As the BFS proceeds, shortest path to each cell from the first column is computed. Finally for the reachable cells in the last column, output the minimum distance.
The implementation in C++ is as follows: 
C++
// C++ program to find shortest safe Route in// the matrix with landmines#include <bits/stdc++.h>using namespace std; #define R 12#define C 10 struct Key{    int x,y;    Key(int i,int j){ x=i;y=j;};}; // These arrays are used to get row and column// numbers of 4 neighbours of a given cellint rowNum[] = { -1, 0, 0, 1 };int colNum[] = { 0, -1, 1, 0 }; // A function to check if a given cell (x, y) is// a valid cell or notbool isValid(int x, int y){    if (x < R && y < C && x >= 0 && y >= 0)        return true;     return false;} // A function to mark all adjacent cells of// landmines as unsafe. Landmines are shown with// number 0void findShortestPath(int mat[R][C]){    int i,j;     for (i = 0; i < R; i++)    {        for (j = 0; j < C; j++)        {            // if a landmines is found            if (mat[i][j] == 0)            {            // mark all adjacent cells            for (int k = 0; k < 4; k++)                if (isValid(i + rowNum[k], j + colNum[k]))                    mat[i + rowNum[k]][j + colNum[k]] = -1;            }        }    }// mark all found adjacent cells as unsafe    for (i = 0; i < R; i++)    {        for (j = 0; j < C; j++)        {            if (mat[i][j] == -1)                mat[i][j] = 0;        }    }     int dist[R][C];     for(i=0;i<R;i++){        for(j=0;j<C;j++)            dist[i][j] = -1;    }    queue<Key> q;     for(i=0;i<R;i++){        if(mat[i][0] == 1){            q.push(Key(i,0));            dist[i][0] = 0;        }    }     while(!q.empty()){        Key k = q.front();        q.pop();         int d = dist[k.x][k.y];         int x = k.x;        int y = k.y;         for (int k = 0; k < 4; k++) {            int xp = x + rowNum[k];            int yp = y + colNum[k];            if(isValid(xp,yp) && dist[xp][yp] == -1 && mat[xp][yp] == 1){                dist[xp][yp] = d+1;                q.push(Key(xp,yp));            }        }    }    // stores minimum cost of shortest path so far    int ans = INT_MAX;    // start from first column and take minimum    for(i=0;i<R;i++){        if(mat[i][C-1] == 1 && dist[i][C-1] != -1){            ans = min(ans,dist[i][C-1]);        }    }         // if destination can be reached    if(ans == INT_MAX)        cout << "NOT POSSIBLE\n";             else// if the destination is not reachable        cout << "Length of shortest safe route is " << ans << endl;} // Driver codeint main(){         // input matrix with landmines shown with number 0    int mat[R][C] =    {        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 0, 1, 1, 1, 1, 1, 1, 0, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 },        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },        { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 }    };         // find shortest path    findShortestPath(mat);}
Output: 
Length of shortest safe route is 13
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
geekoverflow
sanjeev2552
ruhelaa48
varshagumber28
decode2207
rameshtravel07
mukesh07
Shortest Path
Backtracking
Matrix
Matrix
Shortest Path
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Backtracking | Introduction
m Coloring Problem | Backtracking-5
Print all paths from a given source to a destination
Subset Sum | Backtracking-4
Backtracking to find all subsets
Matrix Chain Multiplication | DP-8
Program to find largest element in an array
Print a given matrix in spiral form
Divide and Conquer | Set 5 (Strassen's Matrix Multiplication)
Find the number of islands | Set 1 (Using DFS)