LeetCode Online Judge 题目C# 练习 - 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.

递归：

 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         }

DP：

 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         }

代码分析：

　　经典的递归(Top-down)，DP(Bottom-up)题。DP一般都比递归来的效率高,主要是每次function 调用都新创建一个stack，但是有些问题递归用的巧，也是让人为之一震！

　　

转载于:https://www.cnblogs.com/etcow/archive/2012/09/29/2707935.html