1         public static int MinimumPathSum(List<List<int>> grid)
 2         {
 3             int m = grid.Count;
 4             int n = grid[0].Count;
 5
 6             return MinimumPathSumRecursive(grid, m - 1, n - 1);
 7         }
 8
 9         public static int MinimumPathSumRecursive(List<List<int>> grid, int x, int y)
10         {
11             if (x == 0 && y == 0)
12             {
13                 return grid[0][0];
14             }
15             else if (x == 0)
16             {
17                 return MinimumPathSumRecursive(grid, 0, y - 1) + grid[0][y];
18             }
19             else if (y == 0)
20             {
21                 return MinimumPathSumRecursive(grid, x - 1, 0) + grid[x][0]; ;
22             }
23             else
24             {
25                 return Math.Min(MinimumPathSumRecursive(grid, x - 1, y), MinimumPathSumRecursive(grid, x, y - 1)) + grid[x][y];
26             }
27         }

 1         public static int MinimumPathSumDP(List<List<int>> grid)
 2         {
 3             int m = grid.Count;
 4             int n = grid[0].Count;
 5
 6             int[,] ret = new int[m, n];
 7
 8             for (int i = 0; i < m; i++)
 9             {
10                 for (int j = 0; j < n; j++)
11                 {
12                     if (i == 0 && j == 0)
13                     {
14                         ret[i, j] = grid[0][0];
15                         continue;
16                     }
17                     if (i == 0)
18                     {
19                         ret[i, j] = ret[i, j - 1] + grid[i][j];
20                         continue;
21                     }
22                     if (j == 0)
23                     {
24                         ret[i, j] = ret[i - 1, j] + grid[i][j];
25                         continue;
26                     }
27
28                     if (ret[i - 1, j] <= ret[i, j - 1])
29                     {
30                         ret[i, j] = ret[i - 1, j] + grid[i][j];
31                         continue;
32                     }
33                     else
34                     {
35                         ret[i, j] = ret[i, j - 1] + grid[i][j];
36                         continue;
37                     }
38
39                 }
40             }
41
42             return ret[m - 1, n - 1];
43         }