LeetCode 576. Out of Boundary Paths

题解

这道题我觉得难在内容理解，怎么程序表述出这样的一个目的。
一开始我想了个bfs的，我想是从起点算移动到某位置时还剩下多少步数，如果
剩余步数大于0而该位置在边界上那么该位置+1，最后遍历四周边界位置累加其数字即可。
思路正确但是爆内存(剪枝一样爆)，而且有点不是很透彻的感觉。

看了下dp的题解，觉得舒服多了。
三维dp[ i, j , k]：代表从i-j开始走k步能走出界的方法数。
这个描述非常简练自然，转移公式也很自然。
dp[ i, j, k ] = dp[i-1, j, k-1] + dp[i, j-1, k-1] + dp[i+1, j, k-1] + dp[i, j+1, k-1]
边界条件: dp[ i,j,0]=0，dp[i, j, k]=1 where [i, j]越界

---

Code

DP accept

class Solution {
public:
    int f[51][51][51];
    int dx[4]={1,-1,0,0};
    int dy[4]={0,0,-1,1};
    static const int mmd = 1000000007;
    int findPaths(int m, int n, int N, int _i, int _j) {
        if(N==0) return 0;
        memset(f,0,sizeof(f));
        int nx,ny;
        for(int k=1;k<=N;k++){
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    int tmp=0;
                    for(int t=0;t<4;t++){
                        nx=i+dx[t];
                        ny=j+dy[t];
                        if(nx<0||nx>=m||ny<0||ny>=n) tmp+=1;
                        else tmp+=(f[nx][ny][k-1]%mmd);
                        tmp%=mmd;// 坑
                    }
                    f[i][j][k] = tmp%mmd;
                }
            }
        }
        return f[_i][_j][N]%mmd;    
    }
};

MEL BFS 超出内存

    int findPaths(int m, int n, int N, int i, int j) {
        if(N==0) return 0;
        
        memset(f,0,sizeof(f));
        queue<pair<int,int>> que;
        que.push({i,j});
        int cur_n,nx,ny;
        pair<int,int> tmp;
        while(N--){
            cur_n = que.size();
            for(int k=0;k<cur_n;k++){
                tmp = que.front();
                que.pop();
                f[tmp.first][tmp.second]++;
                nx=tmp.first;
                ny=tmp.second;
                
                if( min(min(nx,ny),min(m-nx-1,n-ny-1)) >= N ) continue;
                
                for(int t=0;t<4;t++){
                    nx=tmp.first + dx[t];
                    ny=tmp.second + dy[t];
                    if( nx>=0 && nx <m && ny>=0 && ny <n)
                        que.push({nx,ny});
                }
            }
        }
        int ans=0;
        for(int k=0;k<n;k++) {
            if(f[0][k]>0) ans+=f[0][k];
            if(f[m-1][k]>0) ans+=f[m-1][k];
            ans%=mmd;
        }
        for(int k=0;k<m;k++) {
            if(f[k][0]>0) ans+=f[k][0];
            if(f[k][n-1]>0) ans+=f[k][n-1];
            ans%=mmd;
        }
        return ans%(mmd);
    }