Dungeon Game

                            Solution in C :

int calculateMinimumHP(int** dungeon, int dungeonSize, int* dungeonColSize){
    int m = dungeonSize;
    int n = *dungeonColSize ;
    int** dp = malloc(m * sizeof(int*)) ;
    for(int i = 0; i < m; i++){
        dp[i] = malloc(n * sizeof(int)) ;
    }
    for(int i = m-1; i >= 0; i--){
        for(int j = n-1; j >= 0; j--){
            if(i == m-1 && j == n-1)
                dp[i][j] = 1 ;
            else if(i == m-1)
                dp[i][j] = dp[i][j+1] - dungeon[i][j+1] ;
            else if(j == n-1)
                dp[i][j] = dp[i+1][j] - dungeon[i+1][j] ;
            else
                dp[i][j] = fmin(dp[i][j+1] - dungeon[i][j+1] , dp[i+1][j] - dungeon[i+1][j]) ;
            dp[i][j] = fmax(1, dp[i][j]) ;
        }
    }
    int ret = dp[0][0] - dungeon[0][0] ;
    for(int i = 0; i < m; i++)
        free(dp[i]) ;
    free(dp) ;
    return fmax(ret , 1) ;
}
                        

                        Solution in C++ :

class Solution {
public:
    int solve (vector<vector<int>>& dungeon,vector<vector<int>>& dp,int i,int j,int m ,int n){
        if(i==m || j==n)
        return INT_MAX;

        if(i==m-1 && j==n-1)
        return dungeon[i][j]<=0 ? -dungeon[i][j]+1 : 1;

        if(dp[i][j]!=INT_MAX)
        return dp[i][j];

        int right = solve(dungeon,dp,i,j+1,m,n);
        int down = solve(dungeon,dp,i+1,j,m,n);

        int ans = min(right,down)-dungeon[i][j];

        return dp[i][j]= ans<=0?1:ans;

}
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int m = dungeon.size();
        int n = dungeon[0].size();

        vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));

        return solve(dungeon,dp,0,0,m,n);
    }
};
                    

                        Solution in Java :

class Solution 
{   
    int[][] dp; int rows, cols;
    public int calculateMinimumHP(int[][] A)
    {
        rows = A.length; cols = A[0].length;
        dp = new int[rows][cols];
        
        calculateMinimumHPHelper(A, 0, 0);
        return dp[0][0];
    }
    public int calculateMinimumHPHelper(int[][] A, int i, int j)
    {
        if(i >= rows || j >= cols)
            return Integer.MAX_VALUE;
       
        if(dp[i][j] > 0)
            return dp[i][j];
            
        int leftPath = calculateMinimumHPHelper(A, i, j+ 1);
        int rightPath = calculateMinimumHPHelper(A, i + 1, j);
        
        if(leftPath == Integer.MAX_VALUE && rightPath == Integer.MAX_VALUE)
        {
            dp[i][j] = A[i][j] > 0 ? 1 : Math.abs(A[i][j]) + 1;
            return dp[i][j];
        }   
        int bestPath = Math.min(leftPath, rightPath);
        
        if(A[i][j] > 0)
            dp[i][j] = Math.max(bestPath - A[i][j], 1);
            
        else
            dp[i][j] = Math.abs(A[i][j]) + bestPath;
        
        return dp[i][j];
    }
}
                    

                        Solution in Python : 
                            
class Solution:
  def calculateMinimumHP(self, dungeon: List[List[int]]) -> int:
    m = len(dungeon)
    n = len(dungeon[0])
    dp = [math.inf] * (n + 1)
    dp[n - 1] = 1

    for i in reversed(range(m)):
      for j in reversed(range(n)):
        dp[j] = min(dp[j], dp[j + 1]) - dungeon[i][j]
        dp[j] = max(dp[j], 1)

    return dp[0]