120. 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.

这是一道典型的dp问题的题目，我的第一种解法很直接，思路也很简单就是自顶向下的遍历一整个三角数组，然后每一个节点都记录到这个节点的最短距离，这样时间复杂度和空间复杂度都是O(n * n)
以下是我的程序：

class Solution {public:    int minimumTotal(vector<vector<int>>& triangle) {        int n = 0;        int size = 0;        int pos = 0;        int sum = 0;        int small = 0;        std::vector<std::vector<int>> vec;        n = triangle.size();        if (n <= 0)            return sum;        std::vector<int> v;        v.push_back(triangle[0][0]);        vec.push_back(v);        for (int i = 1; i < n; i++) {            size = triangle[i].size();            std::vector<int> vec_small;            sum = vec[i - 1][0] + triangle[i][0];            vec_small.push_back(sum);            for (int j = 1; j < size - 1; j++) {                small = vec[i - 1][j - 1] <                    vec[i - 1][j] ?                     vec[i - 1][j - 1] : vec[i - 1][j];                sum = triangle[i][j] + small;                vec_small.push_back(sum);            }            sum = triangle[i][size - 1] +                     vec[i - 1][size - 2];            vec_small.push_back(sum);            vec.push_back(vec_small);        }        n = vec.size();        size = vec[n - 1].size();        small = vec[n - 1][0];        for (int i = 1; i < size; i++)            if (small > vec[n - 1][i])                small = vec[n - 1][i];               return small;    }};

但是我觉得这样的方式并不是很好，后来又改进了下，没有申请空间，而是直接在原来的三角数组上进行更改，虽然空间复杂度是O(1)但是这种方法的话不能保存数组的值，也不是很好，先看看程序：

class Solution {public:    int minimumTotal(vector<vector<int>>& triangle) {        //这种方法直接利用的就是原来的数组，每一次记录的都是        //到当前节点的最小的步数之和。这样可以节省空间，但是不能保存下原来的数据        //我使用的是top-down的方法，但是在讨论里面别人使用的是bottom-up的方法；        //我觉得bottom-up的方法很好，节约空间，实现起来也不会很难        int n = 0;        int size = 0;        int pos = 0;        int sum = 0;        int small = 0;        n = triangle.size();        if (n <= 0)            return sum;        for (int i = 1; i < n; i++) {            size = triangle[i].size();            sum = triangle[i - 1][0] + triangle[i][0];            triangle[i][0] = sum;            for (int j = 1; j < size - 1; j++) {                small = triangle[i - 1][j - 1] <                 triangle[i - 1][j] ?                     triangle[i - 1][j - 1] :                     triangle[i - 1][j];                sum = triangle[i][j] + small;                triangle[i][j] = sum;            }            sum = triangle[i][size - 1] +             triangle[i - 1][size - 2];            triangle[i][size - 1] = sum;        }        n = triangle.size();        size = triangle[n - 1].size();        small = triangle[n - 1][0];        for (int i = 1; i < size; i++)            if (small > triangle[n - 1][i])                small = triangle[n - 1][i];               return small;    }};

最后看了讨论里面别人的算法，发现还可以从底部遍历回去，这样可以做到O(n * n)的时间复杂度和O(n)的空间复杂度，以下是程序：

class Solution {public:    int minimumTotal(vector<vector<int>>& triangle) {        int n = triangle.size();        if (n == 0)            return 0;        int num = 0;        int size = triangle[n - 1].size();        int* arr = new int[size];        int small = 0;        for (int i = 0; i < size; i++)            arr[i] = triangle[n - 1][i];        for (int i = n - 2; i >= 0; i--) {            size = triangle[i].size();            for (int j = 0; j < size; j++) {                small = arr[j] < arr[j + 1] ?                     arr[j] : arr[j + 1];                arr[j] = small + triangle[i][j];            }        }        num = arr[0];        delete []arr;        return num;    }};

好啦，基本就是这样啦。