分享一个有趣的BUG

题目来源：Triangle
这道题目并不复杂， 要求求出一个数字组成的等腰三角形中从底到顶点的最小路径和，这里的路径的父子关系指的是三角形中的每个元素与下一层相邻的两个元素：

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

比如在上面的例子中第二行的第一个元素3可以和第三层的6， 5相通， 但是不能和7相通。

方法一：

写法上最简单， 时间复杂度最高的办法就是DFS， 可以预想到， 这种方法在数据比较大的时候必然会超时的：

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

所以这时候需要用动态规划了：

方法二：

class Solution {
public:
   int minimumTotal(vector<vector<int> > &triangle) {
        if (triangle.empty()) return 0;
        vector<int> cache(triangle.size(), -1);
        return minimumTotal(triangle, 0, 0, cache);
    }

    int minimumTotal(vector<vector<int>> &triangle, int i, int j, vector<int> &cache) {
        if (i == triangle.size() - 1 || j <= cache[i]) return triangle[i][j];
        int x = minimumTotal(triangle, i + 1, j, cache);
        int y = minimumTotal(triangle, i + 1, j + 1, cache);
        triangle[i][j] += std::min(x, y);
        cache[i] = std::max(j, cache[i]);
        return triangle[i][j];
    }
};

这样写相当于从下往上， 从左往右依次把每个节点元素替换为以该元素为顶点的三角形的最短路径和， 缓存cache保存了每一层已经计算完成的路径和的节点序号， 以后每次计算子树的路径和，首先查看该层的路径和有没有已经计算完毕， 如果已经计算完毕， 就直接返回顶点元素（如果该层的元素j索引小于cache[i]， 那可以确定triangle[i][j]中存的就是最短路径和），缩短计算时间， 也符合题目中要求的用O(n)额外空间的要求。

但是第一次我为了图方便是这样写的：

class Solution {
public:
   int minimumTotal(vector<vector<int> > &triangle) {
        if (triangle.empty()) return 0;
        vector<int> cache(triangle.size(), 0);
        return minimumTotal(triangle, 0, 0, cache);
    }

    int minimumTotal(vector<vector<int>> &triangle, int i, int j, vector<int> &cache) {
        if (i == triangle.size() - 1 || j <= cache[i]) return triangle[i][j];
        triangle[i][j] += std::min(minimumTotal(triangle, i + 1, j, cache),
                                         minimumTotal(triangle, i + 1, j + 1, cache));
        cache[i] = std::max(j, cache[i]);
        return triangle[i][j];
    }
};

乍一看这样的写法似乎更加简单， 舍弃了临时变量，其他并没有什么变化。但事实上这是一种错误的写法。原因在于我们的算法必须要保证计算顺序从下往上， 从左往右， 这样cache里边的索引值才是有意义的， 如果不能保证这个计算顺序的话程序的执行结果一定是错误的，靠什么保证这个顺序呢？函数调用参数中出现的先后顺序可以么？当然不行， 不止一本书上告诉我们函数参数的执行顺序未定义， 这就是出现在上面这段代码中的很隐蔽的BUG。所以唯一的方法就是用临时变量， 强制先算左孩子， 然后右孩子。

方法三：

除了这样从上往下递归， 还可以从下往上， 整个程序逻辑变得更加简单：

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