64. Minimum Path Sum [LeetCode]

/**************************************************************************
 * 
 * 64. [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/)
 * 
 * Given a m x n grid filled with non-negative numbers, 
 * find a path from top left to bottom right, which minimizes the sum of 
 * all numbers along its path. 
 * Note: You can only move either down or right at any point in time.
 * 
 * Example :
 * Input:
 * [
 *   [1,3,1],
 *   [1,5,1],
 *   [4,2,1]
 * ]
 * Output: 7
 * Explanation: Because the path 1→3→1→1→1 minimizes the sum.
 * 
 **************************************************************************/


/// DFS, Iteration, using ugly C 
int minPathSum(int** grid, int gridSize, int* gridColSize){
    if (NULL == grid || NULL == gridColSize) return 0;
    int *f = (int *)calloc(*gridColSize, sizeof(int));
    f[0] = grid[0][0];
    for (int i = 1; i < *gridColSize; i++)
        f[i] = f[i-1] + grid[0][i];
    for (int i = 1; i < gridSize; i++) {
        for (int j = 0; j < *gridColSize; j++) {
            f[j] = j == 0 ? f[0] + grid[i][0] : fmin(f[j], f[j-1]) + grid[i][j];
        }
    }
    int res = f[*gridColSize-1];
    free(f);
    return res;
}



/// DFS, Iteration, using C++
class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        const int m = grid.size();
        const int n = grid[0].size();
        vector<int> f(n, INT_MAX);
        f[0] = 0;
        for (int i = 0; i < m; i++) {
            f[0] += grid[i][0];
            for (int j = 1; j < n; j++) {
                f[j] = min(f[j - 1], f[j]) + grid[i][j];
            }
        }
        return f[n - 1];
    }
};



/// DFS, Recursion, using ugly C
static int **create(int rows, int cols) {
    if (rows <=0 || cols <= 0) return NULL;  
    int **f = (int **)calloc(rows, sizeof(int *));
    for (int i = 0; i < rows; i++) {
        f[i] = (int *)calloc(cols, sizeof(int));
        for (int j = 0; j < cols; j++) {
            f[i][j] = INT_MAX;
        }
    }
    return f;
}

static void destroy(int **f, int rows) {
    for (int i = 0; i < rows; i++)
        free(f[i]);
    free(f);
}

static int dfs(int **grid, int **f, int x, int y) {
    if (x < 0 || y < 0)  return INT_MAX;
    if (x == 0 && y == 0) return grid[0][0];
    if (f[x][y] ^ INT_MAX) return f[x][y];
    f[x][y] = grid[x][y] + fmin(dfs(grid, f, x-1, y), dfs(grid, f, x, y-1));
    return f[x][y];
}

int minPathSum(int **grid, int gridSize, int *gridColSize){
    if (NULL == grid || NULL == gridColSize || 0 == gridSize || 0 == *gridColSize) 
        return 0;
    //if (1 == gridSize && 1 == *gridColSize) 
    //    return grid[0][0];
    int **f = create(gridSize, *gridColSize);
    f[0][0] = grid[0][0];
    dfs(grid, f, gridSize - 1, *gridColSize - 1);
    int res = f[gridSize - 1][*gridColSize - 1];
    destroy(f, gridSize);
    return res;
}




/// DFS, Recursion, using C++
class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        vector<vector<int> > f(grid.size(), vector<int>(grid[0].size(), INT_MAX));
        return dfs(grid, f, grid.size() - 1, grid[0].size() - 1);
    }
private:
    int dfs(const vector<vector<int> > &grid, vector<vector<int> > &f, int x, int y) {
        if (x < 0 || y < 0)  return INT_MAX;
        if (x == 0 && y == 0) return grid[0][0];
        if (f[x][y] ^ INT_MAX) return f[x][y];
        f[x][y] = grid[x][y] + fmin(dfs(grid, f, x-1, y), dfs(grid, f, x, y-1));
        return f[x][y];
    }
};