Runtime: 116 ms (Top 86.9%) | Memory: 64.20 MB (Top 40.0%)

Author: AnasImloul

scripts/algorithms/C/Check if There is a Valid Path in a Grid/Check if There is a Valid Path in a Grid.cpp

@@ -1,63 +1,49 @@
+// Runtime: 116 ms (Top 86.9%) | Memory: 64.20 MB (Top 40.0%)
+
 class Solution {
+    int n,m;
+    bool vis[305][305];
+    vector<vector<int>>g;
 public:
-    
-    bool hasValidPath(vector<vector<int>>& grid) 
-    {
-        int m = grid.size();
-        int n = grid[0].size();
-        if(m==1 and n==1) return true;
-        // 2D - direction vector for all streets
-        // 0th based indexing 0 to 11
-        
-        // Let grid value g[i][j] = 4, means we need to follow "street-4" direction
-        // First index of street-4 direction = 2*(4-1) = 6
-        // Second index of street-4 direction = 2*(4-1)+1 = 7
-        // dir[6] = {0, 1}
-        // dir[7] = {1, 0}
-        vector<vector<int>>dir = {        // Indices   
-            {0,-1}, {0, 1}, // street 1  -->  0  1
-            {-1,0}, {1, 0}, // street 2  -->  2  3
-            {0,-1}, {1, 0}, // street 3  -->  4  5
-            {0, 1}, {1, 0}, // street 4  -->  6  7
-            {0,-1}, {-1,0}, // street 5  -->  8  9 
-            {0, 1}, {-1,0}  // street 6  -->  10  11
-        };
+    bool hasValidPath(vector<vector<int>>& grid) {
+        n = grid.size();
+        m = grid[0].size();
+        g = grid;
+        memset(vis, false, sizeof(vis));
+        dfs(0,0);
+        return vis[n-1][m-1];
+    }
+
+    void dfs(int ux, int uy){
+        vis[ux][uy]=true;
+        int vx,vy;
 
-        vector<vector<bool>>vis(m, vector<bool>(n, false));
-        queue<pair<int,int>>q;
-        
-        q.push({0, 0});
-        vis[0][0] = true;
-        
-        while (!q.empty()) 
-        {
-            auto cur = q.front(); q.pop();
+        if(g[ux][uy] == 1 || g[ux][uy]==4 || g[ux][uy]==6) {vx=ux, vy=uy+1; if(valid(vx, vy) && L_enter(vx,vy)) dfs(vx, vy);}
+        if(g[ux][uy] == 1 || g[ux][uy]==3 || g[ux][uy]==5) {vx=ux, vy=uy-1; if(valid(vx, vy) && R_enter(vx,vy)) dfs(vx, vy);}
+        if(g[ux][uy] == 2 || g[ux][uy]==3 || g[ux][uy]==4) {vx=ux+1, vy=uy; if(valid(vx, vy) && D_enter(vx,vy)) dfs(vx, vy);}
+        if(g[ux][uy] == 2 || g[ux][uy]==5 || g[ux][uy]==6) {vx=ux-1, vy=uy; if(valid(vx, vy) && U_enter(vx,vy)) dfs(vx, vy);} 
 
-            int r = cur.first;
-            int c = cur.second;
-            int val = grid[r][c] - 1; // grid values 1 to 6
-            
-            if(r==m-1 and c==n-1) return true;
-            
-            // 2 directions from every cell
-            for(int k=0;k<2;k++) // k = 0, k = 1
-            {
-                int idx = 2*val+k;   // get index
-                int nr = r + dir[idx][0];
-                int nc = c + dir[idx][1];
-                if (nr < 0 or nr >= m or nc < 0 or nc >= n or vis[nr][nc]==true) continue;
-                
-                //  for checking the back direction matches with current cell i.e forming path to next cell
-                for(int x=0;x<2;x++)
-                {
-                    int i = 2*(grid[nr][nc]-1)+x;   // get index
-                    if(r == nr+dir[i][0] and c == nc+dir[i][1]){
-                        vis[nr][nc] = true;
-                        q.push({nr, nc});
-                    }       
-                }
-            }
-        }
+    }
+    bool valid(int x , int y){
+        if(x>=0 && y>=0 && x<n && y<m && !vis[x][y] ) return true;
+        return false;
+    }
+    bool L_enter(int x, int y){
+        if(g[x][y]%2) return true;
+        return false;
+    }
+    bool R_enter(int x, int y){
+        if(g[x][y]==1 || g[x][y]==4 || g[x][y]==6) return true;
+        return false;
+    }
+    bool D_enter(int x, int y)
+    {
+        if(g[x][y]==2 || g[x][y]==5 || g[x][y]==6) return true;
+        return false;
+    }
+     bool U_enter(int x, int y)
+    {
+        if(g[x][y]==2 || g[x][y]==3 || g[x][y]==4) return true;
         return false;
     }
 };