[每日算法] leetcode第112题 Triangle

112 Triangle

原题目描述

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

Note:

Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.

题目大意

题目给出一个金字塔二维数组，希望从金字塔的顶部往下找到一条道路，使得该道路上的数字相加的和最小。（Note：希望我们能够以O(n)的额外空间复杂度解决问题）。

解题思路及代码实现

一、初始想法：
看到，题目，我首先觉得可以使用分治算法，也就是DFS的递归实现，向下递归，每次找到一条道路，返回结果，然后返回上一节点，继续往另一个方向递归，依次找出所有路径，得出最短路径，初始想法代码如下：

// 超时的DFS算法
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        return DFS(triangle, 0, 0, 0);
    }
    int DFS(vector<vector<int>>& triangle, int sum, int x, int y) {
        if (x == triangle.size()-1) {
            return triangle[x][y];
        }
        int sum1 = DFS(triangle, sum, x+1, y);
        int sum2 = DFS(triangle, sum, x+1, y+1);
        return triangle[x][y] + min(sum1, sum2);
    }
};

二、DFS改进
上面初始想法的代码能够得到正确的答案，然而在leetcode上会超时，因为如同斐波那契序列使用递归解法，越到后面的项，重复计算的次数就越多，所以导致计算时间过长而超时，但我们已经计算过了呀，所以没必要每次都重复计算，所以我们可以使用一个数组存起来这些计算结果，下次要去使用时，便不需要再往下计算，只需要取出该值即可（这也是正常的递归解法改进思路），改进之后如下：

// 改进之后的DFS算法（AC）
class Solution {
public:
    int a[1000][1000];
    int minimumTotal(vector<vector<int>>& triangle) {
        for (int i = 0; i < 1000; i++)
            for (int j = 0; j < 1000; j++)
                a[i][j] = 100000000;
        return DFS(triangle, 0, 0);
    }
    int DFS(vector<vector<int>>& triangle, int x, int y) {
        if (a[x][y] != 100000000)
            return a[x][y];
        if (x == triangle.size()-1) {
            return triangle[x][y];
        }
        int sum1 = DFS(triangle, x+1, y);
        int sum2 = DFS(triangle, x+1, y+1);
        a[x][y] = triangle[x][y]+min(sum1, sum2);
        return a[x][y];
    }
};

三、再次改进，不使用递归，且改进空间复杂度
上面解法二的代码，已经能在LeetCode上通过了，所以说DFS能够解决该题了，然而还不够，因为题目的Note要求我们采用一个只使用O(n)复杂度的额外空间来解决该题，很明显，解法二用来存储计算结果的数组已经使用了O(n^2)的额外复杂度，那么我们就需要继续对该算法进行改进，如果能够不使用该数组，那我们便能够解决办法了，但是不使用又无法解决递归计算过多的问题。
既然如此，那就不能考虑递归的思路了，类似斐波那契序列，可以从两个最小项，通过循环，慢慢地推出最大项，那么，我们是否也能够使用循环来解决问题呢？
答案是OK的，通过观察上面的代码，我们能发现，对于下面只有一层节点的节点，它们到最下面节点的最小路径值 = 本身节点值 + min(左节点值，右节点值）。那么接下来我们就可以接着把倒数第二层作为最后一层，继续推出倒数第三层的最小路径值…最终我们就可以推出最上方的节点的最小路径值。
然后，我们每次只需要额外空间存储一层节点的最小路径值即可，越往上，存储的这一层节点数也会越来越少，很明显，我们只需要O(n)的额外空间。
然而，我们可以连这O(n)的复杂度都不需要，直接在原金字塔上修改，只需要O(1)的空间复杂度，最后我们便实现了下面的代码，打败了99.9%提交的解决方案：

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int rows = triangle.size();
        for (int i =rows -2; i >= 0 ; --i){
            for (int j =0; j < triangle[i].size(); ++j){
                triangle[i][j] += min(triangle[i+1][j], triangle[i+1][j+1]);
            }
        }
        return triangle[0][0];
    }
};