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，但是有些问题递归用的巧，也是让人为之一震！