LeetCode 576 出界的路径数[动态规划 状态机] HERODING的LeetCode之路

Posted 2021-09-05 HERODING23

解题思路：
看到取余结果，深搜肯定就用不了了，动态规划才是解决这种问题yyds，首先确定dp[i][j][k]，表示i次到达i，j位置，那么我们对每个位置状态为i的进行四个方向的遍历，更新i + 1位置，如果出界则统计下来，代码如下：

class Solution {
private:
    const int MOD = 1e9 + 7;
    vector<vector<int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
    int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
        int count = 0;
        // dp[i][j][k]表示i次到达i，j位置
        vector<vector<vector<int>>> dp(maxMove + 1, vector<vector<int>>(m, vector<int>(n)));
        dp[0][startRow][startColumn] = 1;
        for(int i = 0; i < maxMove; i ++) {
            for(int j = 0; j < m; j ++) {
                for(int k = 0; k < n; k ++) {
                    int temp = dp[i][j][k];
                    if(temp > 0) {
                        for(auto& direction : directions) {
                            int row = j +direction[0];
                            int col = k + direction[1];
                            // 如果在界内
                            if(row >= 0 && row < m && col >= 0 && col < n) {
                                dp[i + 1][row][col] = (dp[i + 1][row][col] + temp) % MOD;
                            } else {
                                count = (count +temp) % MOD;
                            }
                        }
                    }
                }
            }
        }
        return count;
    }
};

仔细观察发现其实可以优化，就是dp[i + 1][]都是从dp[i]过来的，优化如下：

class Solution {
private:
    const int MOD = 1e9 + 7;
    vector<vector<int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
public:
    int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
        int count = 0;
        // dp[i][j][k]表示i次到达i，j位置
        vector<vector<int>> dp(m, vector<int>(n));
        dp[startRow][startColumn] = 1;
        for(int i = 0; i < maxMove; i ++) {
            vector<vector<int>> dpNew(m, vector<int>(n));
            for(int j = 0; j < m; j ++) {
                for(int k = 0; k < n; k ++) {
                    int temp = dp[j][k];
                    if(temp > 0) {
                        for(auto& direction : directions) {
                            int row = j +direction[0];
                            int col = k + direction[1];
                            // 如果在界内
                            if(row >= 0 && row < m && col >= 0 && col < n) {
                                dpNew[row][col] = (dpNew[row][col] + temp) % MOD;
                            } else {
                                count = (count +temp) % MOD;
                            }
                        }
                    }
                }
            }
            dp = dpNew;
        }
        return count;
    }
};