Leetcode931. Minimum Falling Path Sum下降路径最小和

给定一个方形整数数组 A，我们想要得到通过 A 的下降路径的最小和。

下降路径可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列。

示例：

输入：[[1,2,3],[4,5,6],[7,8,9]] 输出：12 解释： 可能的下降路径有：

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

和最小的下降路径是 [1,4,7]，所以答案是 12。

提示：

1. 1 <= A.length == A[0].length <= 100
2. -100 <= A[i][j] <= 100

典型的动态规划

当前最好的状态和上一层的状态有关。

const int INF = INT_MAX;

class Solution {
public:
    int minFallingPathSum(vector<vector<int> >& A) 
    {
        int r = A.size();
        int c = A[0].size();
        vector<vector<int> > dp(r, vector<int>(c, INF));
        for(int i = 0; i < c; i++)
        {
            dp[0][i] = A[0][i];
        }
        for(int i = 1; i < r; i++)
        {
            for(int j = 0; j < c; j++)
            {
                if(j == 0)
                {
                    dp[i][j] = min(dp[i - 1][j], dp[i - 1][j + 1]) + A[i][j];
                }
                else if(j == c - 1)
                {
                    dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1]) + A[i][j];
                }
                else
                {
                    dp[i][j] = min(dp[i - 1][j], min(dp[i - 1][j - 1], dp[i - 1][j + 1])) + A[i][j];
                }
            }
        }
        int ans = INF;
        for(int i = 0; i < c; i++)
        {
            ans = min(ans, dp[r - 1][i]);
        }
        return ans;
    }
};

因为当前索引的状态只跟上一层的上一个索引状态丶当前索引状态丶下一个索引状态有关。

用一个变量去维护上一层的上一个索引状态，然后再从前往后开始遍历。只需要一维的数组空间就可以了。

优化后：

const int INF = INT_MAX;

class Solution {
public:
    int minFallingPathSum(vector<vector<int> >& A) 
    {
        int r = A.size();
        int c = A[0].size();
        vector<int> dp(c, INF);
        for(int i = 0; i < c; i++)
        {
            dp[i] = A[0][i];
        }
        for(int i = 1; i < r; i++)
        {
            int last = INF;
            for(int j = 0; j < c; j++)
            {
                if(j == 0)
                {
                    last = dp[j];
                    dp[j] = min(dp[j], dp[j + 1]) + A[i][j];
                }
                else if(j == c - 1)
                {
                    dp[j] = min(dp[j], last) + A[i][j];
                }
                else
                {
                    int temp = dp[j];
                    dp[j] = min(dp[j], min(last, dp[j + 1])) + A[i][j];
                    last = temp;
                }
            }
        }
        int ans = INF;
        for(int i = 0; i < c; i++)
        {
            ans = min(ans, dp[i]);
        }
        return ans;
    }
};