DP #64 Minimum Path Sum

class Solution {
    public int minPathSum(int[][] grid) {
        // int r=grid.length,c=grid[0].length;
        // int[][] dp = new int[r][c];
        // for(int[] i:dp) Arrays.fill(i,-1);
        // func(r-1,c-1,grid,dp);
        // return dp[r-1][c-1];
        return tabOpt(grid);
    }

    // Tabulation Space Optimised Solution
    int tabOpt(int[][] ar){
        int r=ar.length,c=ar[0].length;
        int[] dp=new int[c];
        for(int i=0;i<r;i++){
            int[] cur = new int[c];
            for(int j=0;j<c;j++){
                if(i==0&&j==0){
                    cur[j]=ar[i][j];
                    continue;
                }
                int up = ar[i][j]+((i-1>=0)?dp[j]:(int) Math.pow(10, 9));
                int left = ar[i][j]+((j-1>=0)?cur[j-1]:(int) Math.pow(10, 9));
                cur[j]=Math.min(up,left);
            }
            dp=cur;
        }    
        return dp[c-1];
    }

    // Tabulation Solution
    int tab(int[][] ar){
        int r=ar.length,c=ar[0].length;
        int[][] dp=new int[r][c];
        for(int i=0;i<r;i++){
            for(int j=0;j<c;j++){
                if(i==0&&j==0){
                    dp[i][j]=ar[i][j];
                    continue;
                }
                int up = ar[i][j]+((i-1>=0)?dp[i-1][j]:99999);
                int left = ar[i][j]+((j-1>=0)?dp[i][j-1]:99999);
                dp[i][j]=Math.min(up,left);
            }
        }    
        return dp[r-1][c-1];
    }

    // Recursion Memoization Solution
    int recur(int r, int c, int[][] ar, int[][] dp){
        if(r==0&&c==0)return dp[r][c] = ar[r][c];
        if(r<0||c<0) return 99999;
        if(dp[r][c] !=-1) return dp[r][c];
        int up=ar[r][c]+recur(r-1,c,ar,dp);
        int left=ar[r][c]+recur(r,c-1,ar,dp);
        return dp[r][c]=Math.min(up,left);
    }
}