Leetcode 576 Out of Boundary Paths

最新推荐文章于 2024-09-15 15:43:59 发布

anakin7

最新推荐文章于 2024-09-15 15:43:59 发布

阅读量442

点赞数

分类专栏：算法文章标签：动态规划 leetcode

本文链接：https://blog.csdn.net/anakin7/article/details/71787213

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

动态规划。

dp[[i][j][n]表示从（x，y）出发走n步到达（i，j）位置的路径数。

class Solution {
public:
    int findPaths(int m, int n, int N, int I, int J) {
        if (N == 0) {
            return 0;
        }
        typedef long long LL;
        const LL mod = 1000000007;
        vector<vector<vector<LL>>> dp(m, vector<vector<LL>>(n, vector<LL>(N, 0)));
        dp[I][J][0] = 1;
        const int mv[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
        LL ans = 0;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < m; ++j) {
                for (int k = 0; k < n; ++k) {
                    for (int l = 0; l < 4; ++l) {
                        int nx = j + mv[l][0];
                        int ny = k + mv[l][1];
                        if (nx < 0 || nx ==m || ny < 0 || ny == n || i - 1 < 0) {
                            continue;
                        }
                        dp[j][k][i] += dp[nx][ny][i-1];
                        dp[j][k][i] %= mod;
                    }
                    if (j == 0) {
                        ans += dp[j][k][i];
                        ans %= mod;
                    }
                    if (j == m - 1) {
                        ans += dp[j][k][i];
                        ans %= mod;
                    }
                    if (k == 0) {
                        ans += dp[j][k][i];
                        ans %= mod;
                    }
                    if (k == n - 1) {
                        ans += dp[j][k][i];
                        ans %= mod;
                    }
                }
            }
        }
        return static_cast<int>(ans);
    }
};