2021.8.30 三角形最小路径和

题目描述：

给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

方法一：

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<vector<int>> f(n);
        for (int i = 0; i < n; i++)
        {
            f[i].resize(triangle[i].size());
        }
        f[0][0] = triangle[0][0];
        for (int i = 1; i < n; i++)
        {
            for (int j = 0; j < triangle[i].size(); j++)
            {
                int m = triangle[i - 1].size();
                if (j == 0) //当前最左边的结点只能由上一条边的最左边的结点走到
                {
                    f[i][j] = f[i - 1][j] + triangle[i][j];
                }
                else if (j > 0 && j < m) 
                {
                    f[i][j] = min(f[i - 1][j - 1] + triangle[i][j], f[i - 1][j] + triangle[i][j]);
                }
                else if (j == m)    //当前最右边的结点只能由上一条边的最右边的结点走到
                {
                    f[i][j] = f[i - 1][j - 1] + triangle[i][j];
                }
            }
        }
        int minx = INT_MAX;
        for (int i = 0; i < f[n - 1].size(); i++)
        {
            minx = min(f[n - 1][i], minx);
        }
        return minx;
    }
};

这道题用贪心法是不行的，例如样例【{ {-1},{2,3},{1,-1,-3} }】，每次走选取数值最小的结点，得到的结果是0，然而正确答案是-1。

设f[i][j]为走到第i行第j个数字所需要的最小路径和（假设从第0行开始，每行从第0个数字开始），那么f[i][j]的值取决于上一行与它相邻的f[i-1][j-1]和f[i-1][j]中的最小值，当然如果j是边界值需要单独考虑，最后f[n-1]中最小的值即为该三角形的最小路径和。

方法一的改进版：

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<int> f(n);
        f[0] = triangle[0][0];
        for (int i = 1; i < n; i++)
        {
            for (int j = triangle[i].size(); j >= 0; j--)
            {
                int m = triangle[i - 1].size();
                if (j == m) //当前最右边的结点只能由上一条边的最右边的结点走到
                {
                    f[j] = f[j - 1] + triangle[i][j];
                }
                else if (j > 0 && j < m)
                {
                    f[j] = min(f[j - 1] + triangle[i][j], f[j] + triangle[i][j]);
                }
                else if (j == 0)    //当前最左边的结点只能由上一条边的最左边的结点走到
                {
                    f[j] = f[j] + triangle[i][j];
                }
            }
        }
        int minx = INT_MAX;
        for (int i = 0; i < f.size(); i++)
        {
            minx = min(f[i], minx);
        }
        return minx;
    }
};

注意到实际上每次计算动态转移方程时，需要用到的只有f[i-1]这一行的数据，所以实际上只需使用一维数组，利用滚动数组的思想，能够大大提高空间利用率。另外每次遍历滚动时，对于三角形triangle的每一行应该改成从后往前遍历，否则可能会导致后续所需的数据被覆盖。

方法一的再进一步改进版：

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        for (int i = triangle.size()-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];
    }
};

哈哈，自己写完并改进之后心满意足地打开评论区，结果发现还有更强的解法，根本不需要另外开辟一个数组，直接在triangle上修改即可！而且从triangle的最后一行往上遍历，也省去了繁琐的边界条件判断！

做leetcode果真是有趣至极！