Leecode No 576 出界的路径数

 

---

动态规划  

#include<iostream>
#include<vector>
#include<string.h>
using namespace std;

int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
    const int mod=1000000007;
    vector<vector<vector<int>>> dp(maxMove + 1, vector<vector<int>>(m, vector<int>(n)));
   //k-第几步  (x,y)-位置   dp[k][x][y]表示经过k步到达x y的路径数
    dp[0][startRow][startColumn]=1;         //初始点经过0次可以到达
    int res=0;
    vector<vector<int>> direction={{0,1},{1,0},{-1,0},{0,-1}};          //上下左右四个方向
    for(int i=1; i<=maxMove ; i++)
    {
        for(int x=0 ; x<m ;x++)
        {
            for(int y=0 ; y<n ;y++)
            {
                int count=dp[i-1][x][y];        //遍历整个数组
                if(count!=0)                    //这里表示这个点在上一步时是可以到达的,
                {                               //如果在上一步也不能到达就没有讨论的必要
                    for(auto d : direction)     //从该点遍历四个方向
                    {
                        int _x=x+d[0],_y=y+d[1];    //新位置
                        if(_x>=0&&_x<m&&_y>=0&&_y<n)    //新位置还在网格内
                        {
                           dp[i][_x][_y]=(dp[i][_x][_y]+count)%mod; //该新位置可以到达的路径数 等于本身加上旧位置的路径数
                        }
                        else
                             res=(res+count)%mod;       // 出界了结果res加上旧位置的路径数
                    }
                }
            }
        }
    }
    return res;
}

记忆化搜索

const int mod=1000000007;
int MAX,_m,_n;
long int dp[51][51][51];
int dfs(int x,int y,int k)
{
    if(k>MAX) return 0;
    if(x<0||y<0||x>=_m||y>=_n) return 1;
    if(dp[x][y][k]!=-1) return dp[x][y][k];
    else  return dp[x][y][k]=dfs(x+1,y,k+1)+dfs(x-1,y,k+1)+dfs(x,y+1,k+1)+dfs(x,y-1,k+1)%mod;
}
int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
    memset(dp,-1,sizeof(dp));
    MAX=maxMove;
    _m=m;
    _n=n;
    return dfs(startRow,startColumn,0);
}
int main()
{
    cout<<findPaths(1,3,3,0,1);
    return 0;
}