DP #931 Minimum Falling Path Sum

class Solution {
    public int minFallingPathSum(int[][] matrix) {
        // int r=matrix.length,c=matrix[0].length;
        // int ans = (int)Math.pow(10,9);
        // int[][] dp = new int[r][c];
        // for(int[] i:dp) Arrays.fill(i,-1);
        // for(int l=0;l<c;l++){
        //     ans = Math.min(ans,func(r-1,l,matrix,c,dp));
        // }
        // return ans;
        return tab(matrix);
    }

    // Tabulation Space Optimised Solution
    int tabOpt(int[][] ar){
        int r=ar.length,c=ar[0].length;
        int ans = (int)Math.pow(10,9);
        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){
                    cur[j]=ar[0][j];
                    continue;
                }
                int up=ar[i][j]+dp[j];
                int d1=ar[i][j]+((j-1>=0)?dp[j-1]:(int)Math.pow(10,9));
                int d2=ar[i][j]+((j+1<c)?dp[j+1]:(int)Math.pow(10,9));
                cur[j]=Math.min(up,Math.min(d1,d2));
                System.out.println(i+"::"+j+"::"+dp[j]+ " ");
            }
            dp=cur;
        }

        for(int i=0;i<c;i++){
            ans=Math.min(ans,dp[i]);
        }
        return ans;
    }

    // Tabulation Solution
    int tab(int[][] ar){
        int r=ar.length,c=ar[0].length;
        int ans = (int)Math.pow(10,9);
        int[][] dp = new int[r][c];

        for(int i=0;i<r;i++){
            for(int j=0;j<c;j++){
                if(i==0){
                    dp[0][j]=ar[0][j];
                    continue;
                }
                int up=ar[i][j]+dp[i-1][j];
                int d1=ar[i][j]+((j-1>=0)?dp[i-1][j-1]:(int)Math.pow(10,9));
                int d2=ar[i][j]+((j+1<c)?dp[i-1][j+1]:(int)Math.pow(10,9));
                dp[i][j]=Math.min(up,Math.min(d1,d2));
                System.out.println(i+"::"+j+"::"+dp[i][j]+ " ");
            }
        }

        for(int i=0;i<c;i++){     
            ans=Math.min(ans,dp[r-1][i]);
        }
        return ans;
    }

    // Recursion Memoization Solution
    int func(int r, int c, int[][] ar,int lm,int[][] dp){
        if(r<0 ||c<0||c==lm) return (int)Math.pow(10,9);
        if(r==0) return dp[r][c] =ar[r][c];
        if(dp[r][c]!=-1) return dp[r][c];
        int up= ar[r][c] + func(r-1,c,ar,lm,dp);
        int d1=ar[r][c]+func(r-1,c-1,ar,lm,dp);
        int d2=ar[r][c]+func(r-1,c+1,ar,lm,dp);
        return dp[r][c] =Math.min(up,Math.min(d2,d1));
    }
}